def handle(self, *args, **options):
# engine was created by initial_data.yml
my_engine = Engine.objects.get(version='2.4.10',
engine_type__name='mongodb')
my_host = factory.HostFactory(hostname='localhost')
my_env = factory.EnvironmentFactory(name='laboratory')
my_plan = factory.PlanFactory(name='small',
engine_type=my_engine.engine_type,
environments=[my_env])
my_infradb = factory.DatabaseInfraFactory(name='local_infra',
plan=my_plan,
environment=my_env,
engine=my_engine,
capacity=10)
factory.InstanceFactory(databaseinfra=my_infradb, hostname=my_host)
my_role = Role.objects.get_or_create(name="role_dba")[0]
organization = Organization.objects.get_or_create(
name='fake_organization')[0]
my_team = Team.objects.get_or_create(name="my team",
role=my_role,
organization=organization)[0]
my_admin = User.objects.create_superuser('admin',
email='*****@*****.**',
password='******')
my_team.users.add(my_admin)
def _create_database_structure(cls):
mysql_host = settings.DB_HOST
mysql_port = settings.DB_PORT or 3306
cls.mysql_endpoint = '{}:{}'.format(mysql_host, mysql_port)
cls.engine_type = factory_physical.EngineTypeFactory(name=cls.ENGINE)
cls.engine = factory_physical.EngineFactory(
engine_type=cls.engine_type)
cls.disk_offering = factory_physical.DiskOfferingFactory(
size_kb=524288)
cls.plan = factory_physical.PlanFactory(
disk_offering=cls.disk_offering, engine=cls.engine)
cls.databaseinfra = factory_physical.DatabaseInfraFactory(
name="__test__ mysqlinfra2",
user="******",
password=settings.DB_PASSWORD,
endpoint=cls.mysql_endpoint,
engine=cls.engine,
disk_offering=cls.disk_offering,
plan=cls.plan)
cls.hostname = factory_physical.HostFactory()
cls.instances = cls.instance_helper.create_instances_by_quant(
instance_type=Instance.MYSQL,
qt=cls.instances_quantity,
infra=cls.databaseinfra,
hostname=cls.hostname)
cls.instance = cls.instances[0]
cls.database = factory_logical.DatabaseFactory(
name='test_db_1',
databaseinfra=cls.databaseinfra,
)
cls.volume = factory_physical.VolumeFactory(
host=cls.hostname, used_size_kb=cls.database.used_size_in_kb)
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory(
password="******", endpoint="127.0.0.1:6379")
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, port=6379, instance_type=4)
self.driver = Redis(databaseinfra=self.databaseinfra)
self._redis_client = None
def _create_database(self, env_name='fake_env',
infra_name='__test__ mysqlinfra2'):
environment = factory_physical.EnvironmentFactory(
name=env_name
)
databaseinfra = factory_physical.DatabaseInfraFactory(
name=infra_name,
user="******", password='******',
engine=self.engine,
plan=self.plan,
ssl_configured=True,
environment=environment
)
hostname = factory_physical.HostFactory(
ssl_expire_at=FAKE_TODAY + timedelta(days=16)
)
self.instance_helper.create_instances_by_quant(
instance_type=Instance.MYSQL, qt=1,
infra=databaseinfra, hostname=hostname
)
database = factory_logical.DatabaseFactory(
name='test_db_1',
databaseinfra=databaseinfra,
)
return environment, databaseinfra, hostname, database
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory(
user="******", password="", endpoint="127.0.0.1:3306")
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, port=3306)
self.driver = MySQL(databaseinfra=self.databaseinfra)
self._mysql_client = None
def _create_database_structure(cls):
mysql_host = settings.DB_HOST
mysql_port = settings.DB_PORT or 3306
cls.mysql_endpoint = '{}:{}'.format(mysql_host, mysql_port)
cls.engine_type = factory_physical.EngineTypeFactory(name='mysql')
cls.engine = factory_physical.EngineFactory(
engine_type=cls.engine_type)
cls.disk_offering = factory_physical.DiskOfferingFactory(
size_kb=524288)
cls.plan = factory_physical.PlanFactory(
disk_offering=cls.disk_offering, engine=cls.engine)
cls.databaseinfra = factory_physical.DatabaseInfraFactory(
name="__test__ mysqlinfra2",
user="******",
password=settings.DB_PASSWORD,
endpoint=cls.mysql_endpoint,
engine=cls.engine,
disk_offering=cls.disk_offering,
plan=cls.plan)
cls.hostname = factory_physical.HostFactory()
cls.instance = factory_physical.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
instance_type=Instance.MYSQL,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.database = factory_logical.DatabaseFactory(
name='test_db_1',
databaseinfra=cls.databaseinfra,
)
cls.nfsaas_host_attr = factory_physical.NFSaaSHostAttr(
host=cls.hostname,
# nfsaas_size_kb=cls.database.total_size_in_kb,
nfsaas_used_size_kb=cls.database.used_size_in_kb)
def setUp(self):
self.today = FAKE_TODAY
self.engine_type = factory_physical.EngineTypeFactory(name='mysql')
self.engine = factory_physical.EngineFactory(
engine_type=self.engine_type)
self.plan = factory_physical.PlanFactory(engine=self.engine)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
name="__test__ mysqlinfra2",
user="******",
password='******',
engine=self.engine,
plan=self.plan,
ssl_configured=True)
self.hostname = factory_physical.HostFactory(ssl_expire_at=FAKE_TODAY +
timedelta(days=16))
self.instances = self.instance_helper.create_instances_by_quant(
instance_type=Instance.MYSQL,
qt=1,
infra=self.databaseinfra,
hostname=self.hostname)
self.instance = self.instances[0]
self.database = factory_logical.DatabaseFactory(
name='test_db_1',
databaseinfra=self.databaseinfra,
)
self.one_month_later = self.today + timedelta(days=30)
def setUp(self):
super(DatabaseAPITestCase, self).setUp()
self.datainfra = physical_factory.DatabaseInfraFactory()
self.instance = physical_factory.InstanceFactory(
address="127.0.0.1", port=27017, databaseinfra=self.datainfra)
self.team = TeamFactory()
self.project = ProjectFactory()
self.environment = self.datainfra.environment
def setUp(self):
mongo_host = os.getenv('TESTS_MONGODB_HOST', '127.0.0.1')
mongo_port = os.getenv('TESTS_MONGODB_PORT', '27017')
self.mongo_endpoint = '{}:{}'.format(mongo_host, mongo_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra, address=mongo_host)
self.driver = MongoDB(databaseinfra=self.databaseinfra)
self._mongo_client = None
def test_get_info_use_caching(self, info):
info.return_value = 'hahaha'
datainfra = factory.DatabaseInfraFactory()
self.assertIsNotNone(datainfra.get_info())
# get another instance to ensure is not a local cache
datainfra = DatabaseInfra.objects.get(pk=datainfra.pk)
self.assertIsNotNone(datainfra.get_info())
info.assert_called_once_with()
def test_get_info_accept_force_refresh(self, info):
info.return_value = 'hahaha'
datainfra = factory.DatabaseInfraFactory()
self.assertIsNotNone(datainfra.get_info())
# get another instance to ensure is not a local cache
datainfra = DatabaseInfra.objects.get(pk=datainfra.pk)
self.assertIsNotNone(datainfra.get_info(force_refresh=True))
self.assertEqual(2, info.call_count)
def setUp(self):
self.plan = physical_factory.PlanFactory()
self.databaseinfra = physical_factory.DatabaseInfraFactory(
plan=self.plan)
self.project = factory.ProjectFactory()
self.user = User.objects.create_superuser(self.USERNAME,
email="*****@*****.**" %
self.USERNAME,
password=self.PASSWORD)
self.client.login(username=self.USERNAME, password=self.PASSWORD)
def setUp(self):
redis_host = settings.REDIS_HOST
redis_port = settings.REDIS_PORT
self.endpoint = "{}:{}".format(redis_host, redis_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
password="******", endpoint=self.endpoint)
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra,
port=redis_port,
instance_type=4,
address=redis_host)
self.driver = Redis(databaseinfra=self.databaseinfra)
self._redis_client = None
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_read_only_fields_editing(self):
infra_factory = factory.DatabaseInfraFactory()
infra_model = DatabaseInfra.objects.get(pk=infra_factory.pk)
admin_read_only = self.admin.get_readonly_fields(request=None,
obj=infra_model)
self.assertEqual(EDITING_PRE_PROVISIONED_READ_ONLY_FIELDS,
admin_read_only)
infra_model.plan.provider = Plan.CLOUDSTACK
admin_read_only = self.admin.get_readonly_fields(request=None,
obj=infra_model)
self.assertEqual(EDITING_CLOUDSTACK_READ_ONLY_FIELDS, admin_read_only)
def setUp(self):
mysql_host = settings.DB_HOST
mysql_port = settings.DB_PORT or 3306
self.mysql_endpoint = '{}:{}'.format(mysql_host, mysql_port)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
user="******",
password=settings.DB_PASSWORD,
endpoint=self.mysql_endpoint)
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra,
address=mysql_host,
port=mysql_port)
self.driver = MySQL(databaseinfra=self.databaseinfra)
self._mysql_client = None
def setUpClass(cls):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.nfaas_host_attr = factory.NFSaaSHostAttr(host=cls.hostname)
cs_offering = factory.CloudStackOfferingFactory(memory_size_mb=9)
cls.infra_offering = factory.DatabaseInfraOfferingFactory(
databaseinfra=cls.databaseinfra, offering=cs_offering)
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)
def setUp(self):
self.plan = physical_factory.PlanFactory()
self.environment = self.plan.environments.all()[0]
self.databaseinfra = physical_factory.DatabaseInfraFactory(
plan=self.plan, environment=self.environment, capacity=10)
self.instance = physical_factory.InstanceFactory(
address="127.0.0.1", port=27017, databaseinfra=self.databaseinfra)
self.project = factory.ProjectFactory()
self.role = Role.objects.get_or_create(name="fake_role")[0]
self.team = Team.objects.get_or_create(
name="fake_team", role=self.role, database_alocation_limit=0)[0]
self.user = User.objects.create_superuser(
self.USERNAME, email="*****@*****.**" % self.USERNAME, password=self.PASSWORD)
self.team.users.add(self.user)
self.client.login(username=self.USERNAME, password=self.PASSWORD)
self.description = "My database"
def test_check_instances_status_is_alert(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,
status=1)
factory.InstanceFactory(address="127.0.0.2",
port=27017,
databaseinfra=datainfra1,
status=0)
self.assertEquals(datainfra1.check_instances_status(),
DatabaseInfra.ALERT)
def setUpClass(cls, instances_mock):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.volume = factory.VolumeFactory(host=cls.hostname)
offering = factory.OfferingFactory(memory_size_mb=9)
offering.environments.add(cls.databaseinfra.environment)
plan = cls.databaseinfra.plan
plan.provider = 1
plan.stronger_offering = offering
plan.weaker_offering = offering
plan.save()
instances_mock.return_value = [cls.instance]
cls.instance.hostname.offering = offering
cls.instance.hostname.save()
def setUp(self):
host = self.host or '127.0.0.1'
port = self.port or 3306
self.infra_endpoint = '{}:{}'.format(host, port)
self.databaseinfra = factory_physical.DatabaseInfraFactory(
password=self.db_password, endpoint="{}:{}".format(host, port),
engine__engine_type__name=self.engine_name, user=self.db_user
)
hostname = factory_physical.HostFactory()
self.volume = factory_physical.VolumeFactory(
host=hostname,
used_size_kb=float(40.0/1024.0)
)
self.instances = self.instance_helper.create_instances_by_quant(
infra=self.databaseinfra, port=self.port, qt=self.instances_quantity,
total_size_in_bytes=0, used_size_in_bytes=0,
instance_type=self.instance_type, hostname=hostname
)
self.instance = self.instances[0]
self.instance_endpoint = "{}:{}".format(self.instance.address, self.instance.port)
self.driver = self.driver_class(databaseinfra=self.databaseinfra)
self._driver_client = None
def test_hosts(self):
plan = factory.PlanFactory()
environment = plan.environments.all()[0]
datainfra = factory.DatabaseInfraFactory(plan=plan,
environment=environment,
capacity=1)
instance = factory.InstanceFactory(address="127.0.0.1",
port=27017,
databaseinfra=datainfra)
host_1 = instance.hostname
instance = factory.InstanceFactory(address="127.0.0.2",
port=27017,
databaseinfra=datainfra)
host_2 = instance.hostname
factory.InstanceFactory(address="127.0.0.3",
port=27017,
databaseinfra=datainfra,
hostname=host_2)
self.assertIn(host_1, datainfra.hosts)
self.assertIn(host_2, datainfra.hosts)
self.assertEqual(len(datainfra.hosts), 2)
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 setUpClass(cls, instances_mock):
cls.databaseinfra = factory.DatabaseInfraFactory(
name="__test__ mysqlinfra", user="******", password='******')
cls.hostname = factory.HostFactory()
cls.instance = factory.InstanceFactory(
address="new_instance.localinstance",
port=123,
is_active=True,
databaseinfra=cls.databaseinfra,
hostname=cls.hostname)
cls.nfaas_host_attr = factory.NFSaaSHostAttr(host=cls.hostname)
cs_offering = factory.CloudStackOfferingFactory(memory_size_mb=9)
cls.infra_offering = factory.DatabaseInfraOfferingFactory(
databaseinfra=cls.databaseinfra, offering=cs_offering)
instances_mock.return_value = [cls.instance]
factory.PlanAttrFactory.create(plan=cls.databaseinfra.plan)
cls.instance.hostname.offering = cs_offering
cls.instance.hostname.save()
offering = cls.databaseinfra.offering
offering.memory_size_mb = 9
offering.save()
cls.databaseinfra.plan.provider = 1
cls.databaseinfra.plan.save()
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.instance = factory_physical.InstanceFactory(
databaseinfra=self.databaseinfra)
self.driver = MongoDB(databaseinfra=self.databaseinfra)
self._mongo_client = None
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.driver = MongoDB(databaseinfra=self.databaseinfra)
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory()
self.database = factory_logical.DatabaseFactory(databaseinfra=self.databaseinfra)
self.credential = factory_logical.CredentialFactory(database=self.database)
self.driver = MongoDB(databaseinfra=self.databaseinfra)
def setUp(self):
self.databaseinfra = factory_physical.DatabaseInfraFactory()
# self.instance = factory_physical.InstanceFactory(databaseinfra=self.databaseinfra)
self.provider = ec2.Ec2Provider()
