def setUp(self):
super(BaseClusterCreateTest, self).setUp()
self.fixture = fixtures.RancherFixture()
self.url = factories.ClusterFactory.get_list_url()
openstack_service_settings = openstack_factories.OpenStackServiceSettingsFactory(
customer=self.fixture.customer
)
self.tenant = openstack_factories.TenantFactory(
service_settings=openstack_service_settings
)
openstack_tenant_factories.FlavorFactory(settings=self.fixture.tenant_settings)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.tenant_settings
)
self.default_security_group = openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.tenant_settings
)
self.fixture.settings.options['base_image_name'] = image.name
self.fixture.settings.save()
self.network = openstack_tenant_factories.NetworkFactory(
settings=self.fixture.tenant_settings
)
self.subnet = openstack_tenant_factories.SubNetFactory(
network=self.network, settings=self.fixture.tenant_settings
)
self.flavor = Flavor.objects.get(settings=self.fixture.tenant_settings)
self.flavor.ram = 1024 * 8
self.flavor.cores = 2
self.flavor.save()
self.fixture.settings.options['base_subnet_name'] = self.subnet.name
self.fixture.settings.save()
def setUp(self):
super(BaseClusterCreateTest, self).setUp()
self.fixture = fixtures.RancherFixture()
self.url = factories.ClusterFactory.get_list_url()
openstack_service_settings = openstack_factories.OpenStackServiceSettingsFactory(
customer=self.fixture.customer)
openstack_service = openstack_factories.OpenStackServiceFactory(
customer=self.fixture.customer,
settings=openstack_service_settings)
openstack_spl = openstack_factories.OpenStackServiceProjectLinkFactory(
project=self.fixture.project, service=openstack_service)
self.tenant = openstack_factories.TenantFactory(
service_project_link=openstack_spl)
settings = ServiceSettings.objects.get(scope=self.tenant)
project = self.fixture.project
instance_spl = OpenStackTenantServiceProjectLink.objects.get(
project=project, service__settings=settings)
openstack_tenant_factories.FlavorFactory(
settings=instance_spl.service.settings)
image = openstack_tenant_factories.ImageFactory(
settings=instance_spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=instance_spl.service.settings)
self.fixture.settings.options['base_image_name'] = image.name
self.fixture.settings.save()
network = openstack_tenant_factories.NetworkFactory(
settings=instance_spl.service.settings)
self.subnet = openstack_tenant_factories.SubNetFactory(
network=network, settings=instance_spl.service.settings)
self.fixture.settings.options['base_subnet_name'] = self.subnet.name
self.fixture.settings.save()
def setUp(self):
self.fixture = fixtures.CostPlanningOpenStackPluginFixture()
self.plan = self.fixture.deployment_plan
self.url = factories.DeploymentPlanFactory.get_url(self.plan, action='evaluate')
self.service = self.fixture.spl.service
self.settings = self.service.settings
self.flavor_params = [
{'cores': 1, 'ram': 1 * 1024, 'name': 'flavor-1'},
{'cores': 2, 'ram': 2 * 1024, 'name': 'flavor-2'},
{'cores': 2, 'ram': 3 * 1024, 'name': 'flavor-3'},
{'cores': 4, 'ram': 4 * 1024, 'name': 'flavor-4'},
]
for p in self.flavor_params:
ot_factories.FlavorFactory(settings=self.settings, **p)
ct_models.DefaultPriceListItem.objects.update_or_create(
resource_content_type=ContentType.objects.get_for_model(ot_models.Instance),
item_type='flavor',
key=p['name'])
ct_factories.DefaultPriceListItemFactory(
resource_content_type=ContentType.objects.get_for_model(ot_models.Volume),
item_type=ot_cost_tracking.VolumeStrategy.Types.STORAGE,
key=ot_cost_tracking.VolumeStrategy.Keys.STORAGE,
)
def _instance_data(user, instance=None):
if instance is None:
instance = factories.InstanceFactory()
factories.FloatingIPFactory(settings=instance.service_settings,
runtime_state='DOWN')
image = factories.ImageFactory(settings=instance.service_settings)
flavor = factories.FlavorFactory(settings=instance.service_settings)
ssh_public_key = structure_factories.SshPublicKeyFactory(user=user)
subnet = factories.SubNetFactory(settings=instance.service_settings)
return {
'name':
'test-host',
'description':
'test description',
'flavor':
factories.FlavorFactory.get_url(flavor),
'image':
factories.ImageFactory.get_url(image),
'service_settings':
factories.OpenStackTenantServiceSettingsFactory.get_url(
instance.service_settings),
'project':
structure_factories.ProjectFactory.get_url(instance.project),
'ssh_public_key':
structure_factories.SshPublicKeyFactory.get_url(ssh_public_key),
'system_volume_size':
max(image.min_disk, 1024),
'internal_ips_set': [{
'subnet': factories.SubNetFactory.get_url(subnet)
}],
}
def test_resource_is_created_when_order_item_is_processed(self):
service_settings = rancher_factories.RancherServiceSettingsFactory()
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.openstack_tenant_service_settings,
ram=1024 * 8,
cores=8,
)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.openstack_tenant_service_settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default',
settings=self.fixture.openstack_tenant_service_settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
order = marketplace_factories.OrderFactory(
project=self.fixture.project, created_by=self.fixture.owner)
ssh_public_key = SshPublicKeyFactory(user=self.fixture.staff)
order_item = marketplace_factories.OrderItemFactory(
order=order,
offering=offering,
attributes={
'name':
'name',
'tenant_settings':
openstack_tenant_factories.
OpenStackTenantServiceSettingsFactory.get_url(
self.fixture.openstack_tenant_service_settings),
'project':
ProjectFactory.get_url(self.fixture.project),
'ssh_public_key':
SshPublicKeyFactory.get_url(ssh_public_key),
'nodes': [{
'subnet':
openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet),
'system_volume_size':
1024,
'memory':
1,
'cpu':
1,
'roles': ['controlplane', 'etcd', 'worker'],
}],
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
marketplace_models.Resource.objects.filter(name='name').exists())
self.assertTrue(
rancher_models.Cluster.objects.filter(name='name').exists())
def trigger_instance_creation(self, **kwargs):
image = openstack_tenant_factories.ImageFactory(
settings=self.service_settings, min_disk=10240, min_ram=1024)
flavor = openstack_tenant_factories.FlavorFactory(
settings=self.service_settings)
subnet_url = openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet)
attributes = {
'flavor':
openstack_tenant_factories.FlavorFactory.get_url(flavor),
'image':
openstack_tenant_factories.ImageFactory.get_url(image),
'name':
'Virtual machine',
'system_volume_size':
image.min_disk,
'internal_ips_set': [{
'subnet': subnet_url
}],
'ssh_public_key':
structure_factories.SshPublicKeyFactory.get_url(
structure_factories.SshPublicKeyFactory(
user=self.fixture.manager)),
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=INSTANCE_TYPE, scope=self.service_settings)
marketplace_factories.OfferingFactory(type=VOLUME_TYPE,
scope=self.service_settings)
# Ensure that SPL exists
self.fixture.spl
order = marketplace_factories.OrderFactory(
project=self.fixture.project,
state=marketplace_models.Order.States.EXECUTING,
)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes=attributes,
order=order,
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.owner)
marketplace_tasks.process_order(serialized_order, serialized_user)
order_item.refresh_from_db()
return order_item
def setUp(self):
self.fixture = openstack_tenant_fixtures.OpenStackTenantFixture()
self.patcher = mock.patch(
'waldur_rancher.backend.RancherBackend.get_cluster_nodes')
self.mocked_get_cluster_nodes = self.patcher.start()
self.mocked_get_cluster_nodes.return_value = [{
'backend_id':
'node_backend_id',
'name':
'name-rancher-node-1'
}]
self.patcher_client = mock.patch(
'waldur_rancher.backend.RancherBackend.client')
self.mock_client = self.patcher_client.start()
self.mock_client.get_node.return_value = backend_node_response
service = rancher_factories.RancherServiceFactory(
customer=self.fixture.customer)
spl = rancher_factories.RancherServiceProjectLinkFactory(
project=self.fixture.project, service=service)
service_settings = spl.service.settings
self.offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
self.plan = marketplace_factories.PlanFactory(offering=self.offering, )
self.offering_component = marketplace_factories.OfferingComponentFactory(
offering=self.offering,
type='node',
billing_type=marketplace_models.OfferingComponent.BillingTypes.
USAGE,
)
self.plan_component = marketplace_factories.PlanComponentFactory(
plan=self.plan,
component=self.offering_component,
)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.spl.service.settings, ram=1024 * 8, cores=8)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.spl.service.settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
self.resource = None
self.cluster = None
self.plan_period = None
def test_resource_is_created_when_order_item_is_processed(self):
service = rancher_factories.RancherServiceFactory(
customer=self.fixture.customer)
spl = rancher_factories.RancherServiceProjectLinkFactory(
project=self.fixture.project, service=service)
service_settings = spl.service.settings
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME, scope=service_settings)
openstack_tenant_factories.FlavorFactory(
settings=self.fixture.spl.service.settings)
image = openstack_tenant_factories.ImageFactory(
settings=self.fixture.spl.service.settings)
openstack_tenant_factories.SecurityGroupFactory(
name='default', settings=self.fixture.spl.service.settings)
service_settings.options['base_image_name'] = image.name
service_settings.save()
order = marketplace_factories.OrderFactory(
project=self.fixture.project, created_by=self.fixture.owner)
order_item = marketplace_factories.OrderItemFactory(
order=order,
offering=offering,
attributes={
'name':
'name',
'nodes': [{
'subnet':
openstack_tenant_factories.SubNetFactory.get_url(
self.fixture.subnet),
'storage':
1024,
'memory':
1,
'cpu':
1,
'roles': ['controlplane', 'etcd', 'worker']
}],
})
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
marketplace_models.Resource.objects.filter(name='name').exists())
self.assertTrue(
rancher_models.Cluster.objects.filter(name='name').exists())
def setUp(self):
user = structure_factories.UserFactory(is_staff=True)
self.client.force_authenticate(user=user)
self.backup = factories.BackupFactory(state=models.Backup.States.OK)
ss = self.backup.service_settings
ss.options = {'external_network_id': uuid.uuid4().hex}
ss.save()
self.url = factories.BackupFactory.get_url(self.backup, 'restore')
system_volume = self.backup.instance.volumes.get(bootable=True)
self.disk_size = system_volume.size
self.service_settings = self.backup.instance.service_settings
self.service_settings.options = {'external_network_id': uuid.uuid4().hex}
self.service_settings.save()
self.valid_flavor = factories.FlavorFactory(
disk=self.disk_size + 10, settings=self.service_settings
)
self.subnet = factories.SubNetFactory(settings=self.service_settings)
def flavor(self):
return tenant_factories.FlavorFactory(settings=self.private_settings)
