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)
