def test_request_is_created_when_order_item_is_processed(self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME,
options={'order': []})
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name': 'item_name',
'description': 'Description'
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
support_models.Offering.objects.filter(name='item_name').exists())
support_offering = support_models.Offering.objects.get(
name='item_name')
resource = marketplace_models.Resource.objects.get(
scope=support_offering)
order_item = marketplace_models.OrderItem.objects.get(
resource=resource)
self.assertTrue(
support_models.Issue.objects.filter(
resource_object_id=order_item.id).exists())
def test_when_order_item_is_approved_openstack_tenant_is_created(self):
# Arrange
fixture = package_fixtures.PackageFixture()
offering = marketplace_factories.OfferingFactory(
scope=fixture.openstack_service_settings, type=PLUGIN_NAME)
order = marketplace_factories.OrderFactory(
state=marketplace_models.Order.States.REQUESTED_FOR_APPROVAL,
project=fixture.project,
)
plan = marketplace_factories.PlanFactory(
scope=fixture.openstack_template)
attributes = dict(
name='My first VPC',
description='Database cluster',
user_username='******',
)
order_item = marketplace_factories.OrderItemFactory(
order=order, offering=offering, attributes=attributes, plan=plan)
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
# Assert
order_item.refresh_from_db()
self.assertTrue(isinstance(order_item.scope, openstack_models.Tenant))
def trigger_virtual_machine_creation(self, **kwargs):
fixture = azure_fixtures.AzureFixture()
service_settings = fixture.settings
azure_models.SizeAvailabilityZone.objects.create(
size=fixture.size, location=fixture.location, zone=1)
attributes = {
'size': azure_factories.SizeFactory.get_url(fixture.size),
'image': azure_factories.ImageFactory.get_url(fixture.image),
'name': 'virtual-machine',
'location':
azure_factories.LocationFactory.get_url(fixture.location),
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=VIRTUAL_MACHINE_TYPE, scope=service_settings)
order = marketplace_factories.OrderFactory(
project=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(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
order_item.refresh_from_db()
return order_item
def setUp(self):
fixture = structure_fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
self.order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'schedules': [
{
'start': '2019-01-03T00:00:00.000000Z',
'end': '2019-01-05T23:59:59.000000Z',
},
],
'name':
'booking',
},
)
serialized_order = core_utils.serialize_instance(self.order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.resource = marketplace_models.Resource.objects.get(name='booking')
self.resource.state = marketplace_models.Resource.States.OK
self.resource.save()
def test_raise_exception_if_order_item_has_not_been_created(self):
self.assertRaises(
exceptions.ResourceTerminateException,
tasks.terminate_resource,
core_utils.serialize_instance(self.resource),
core_utils.serialize_instance(self.user),
)
def trigger_resource_creation(self, **kwargs):
fixture = azure_fixtures.AzureFixture()
service_settings = fixture.settings
attributes = {
'name': 'database-server',
'location': azure_factories.LocationFactory.get_url(),
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=SQL_SERVER_TYPE, scope=service_settings)
order = marketplace_factories.OrderFactory(
project=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(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
order_item.refresh_from_db()
return order_item
def get_delete_instance_tasks(cls, instance, serialized_instance, release_floating_ips):
_tasks = [
core_tasks.BackendMethodTask().si(
serialized_instance,
backend_method='delete_instance',
state_transition='begin_deleting',
),
core_tasks.PollBackendCheckTask().si(
serialized_instance,
backend_check_method='is_instance_deleted',
),
]
if release_floating_ips:
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.BackendMethodTask().si(
core_utils.serialize_instance(floating_ip),
'delete_floating_ip',
).set(countdown=5 if not index else 0))
else:
# pull related floating IPs state after instance deletion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.BackendMethodTask().si(
core_utils.serialize_instance(floating_ip),
'pull_floating_ip_runtime_state',
).set(countdown=5 if not index else 0))
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant:
serialized_executor = core_utils.serialize_class(openstack_executors.TenantPullFloatingIPsExecutor)
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.ExecutorTask().si(serialized_executor, serialized_tenant))
return _tasks
def get_task_signature(cls, instance, serialized_instance, **kwargs):
_tasks = [
core_tasks.StateTransitionTask().si(
serialized_instance, state_transition='begin_updating')
]
# Create non-exist floating IPs
for floating_ip in instance.floating_ips.filter(backend_id=''):
serialized_floating_ip = core_utils.serialize_instance(floating_ip)
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_floating_ip, 'create_floating_ip'))
# Push instance floating IPs
_tasks.append(core_tasks.BackendMethodTask().si(
serialized_instance, 'push_instance_floating_ips'))
# Wait for operation completion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.PollRuntimeStateTask().si(
core_utils.serialize_instance(floating_ip),
backend_pull_method='pull_floating_ip_runtime_state',
success_state='ACTIVE',
erred_state='ERRED',
).set(countdown=5 if not index else 0))
# Pull floating IPs again to update state of disconnected IPs
_tasks.append(core_tasks.IndependentBackendMethodTask().si(
serialized_instance, 'pull_floating_ips'))
return chain(*_tasks)
def test_volume_type_limits_are_propagated(self):
create_offering_components(self.offering)
marketplace_models.OfferingComponent.objects.create(
offering=self.offering,
type='gigabytes_llvm',
billing_type=marketplace_models.OfferingComponent.BillingTypes.
USAGE,
)
response = self.create_order(limits={
'cores': 2,
'ram': 1024 * 10,
'gigabytes_llvm': 10,
})
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
order = marketplace_models.Order.objects.get(
uuid=response.data['uuid'])
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
tenant = order.items.get().resource.scope
self.assertEqual(tenant.quotas.get(name='gigabytes_llvm').limit, 10)
def test_create_confirmation_comment_if_offering_template_is_defined(self):
mock.patch.stopall()
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(
type=PLUGIN_NAME,
options={'order': []},
secret_options={
'template_confirmation_comment':
'template_confirmation_comment'
},
)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name': 'item_name',
'description': 'Description'
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.mock_get_active_backend(
).create_confirmation_comment.assert_called_once_with(
mock.ANY, 'template_confirmation_comment')
def test_set_creation_ticket_id_as_backend_id_of_resource(self):
def mock_create_issue(issue):
issue.backend_id = 'WAL TEST'
issue.save()
self.mock_get_active_backend().create_issue = mock_create_issue
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME,
options={'order': []})
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name': 'item_name',
'description': 'Description'
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
resource = marketplace_models.Resource.objects.get(name='item_name')
issue = support_models.Issue.objects.get(
resource_object_id=order_item.id)
self.assertEqual(issue.backend_id, resource.backend_id)
def test_when_order_item_is_approved_openstack_tenant_is_created(self):
# Arrange
order = marketplace_factories.OrderFactory(
state=marketplace_models.Order.States.REQUESTED_FOR_APPROVAL,
project=self.fixture.project,
)
attributes = dict(
name='My first VPC',
description='Database cluster',
user_username='******',
)
order_item = marketplace_factories.OrderItemFactory(
order=order,
offering=self.offering,
attributes=attributes,
plan=self.plan)
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
# Assert
order_item.refresh_from_db()
self.assertTrue(
isinstance(order_item.resource.scope, openstack_models.Tenant))
def trigger_volume_creation(self, **kwargs):
image = openstack_tenant_factories.ImageFactory(
settings=self.service_settings, min_disk=10240, min_ram=1024)
attributes = {
'image': openstack_tenant_factories.ImageFactory.get_url(image),
'name': 'Volume',
'size': 10 * 1024
}
attributes.update(kwargs)
offering = marketplace_factories.OfferingFactory(
type=VOLUME_TYPE, scope=self.service_settings)
order_item = marketplace_factories.OrderItemFactory(
offering=offering, attributes=attributes)
order_item.order.approve()
order_item.order.save()
service = openstack_tenant_models.OpenStackTenantService.objects.create(
customer=order_item.order.project.customer,
settings=self.service_settings,
)
openstack_tenant_models.OpenStackTenantServiceProjectLink.objects.create(
project=order_item.order.project,
service=service,
)
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)
order_item.refresh_from_db()
return order_item
def test_invoice_is_created_after_pull(self):
self.client_mock().get_invoice_for_customer.return_value = {
'items': []
}
today = datetime.date.today()
self.assertEqual(
0,
Invoice.objects.filter(customer__uuid=self.customer.uuid,
year=today.year,
month=today.month).count(),
)
ResourceInvoicePullTask().run(serialize_instance(self.resource))
self.assertEqual(
1,
Invoice.objects.filter(customer__uuid=self.customer.uuid,
year=today.year,
month=today.month).count(),
)
ResourceInvoicePullTask().run(serialize_instance(self.resource))
self.assertEqual(
1,
Invoice.objects.filter(customer__uuid=self.customer.uuid,
year=today.year,
month=today.month).count(),
)
def test_add_backlink_to_order_item_details_into_created_service_desk_ticket(
self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME,
options={'order': []})
order_item = marketplace_factories.OrderItemFactory(offering=offering,
attributes={
'name':
'item_name',
'description':
'Description'
})
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
support_models.Offering.objects.filter(name='item_name').exists())
offering = support_models.Offering.objects.get(name='item_name')
link_template = settings.WALDUR_MARKETPLACE['ORDER_ITEM_LINK_TEMPLATE']
order_item_url = link_template.format(
order_item_uuid=order_item.uuid,
project_uuid=order_item.order.project.uuid)
self.assertTrue(order_item_url in offering.issue.description)
def create_floating_ips(cls, instance, serialized_instance):
_tasks = []
# Create non-existing floating IPs
for floating_ip in instance.floating_ips.filter(backend_id=''):
serialized_floating_ip = core_utils.serialize_instance(floating_ip)
_tasks.append(core_tasks.BackendMethodTask().si(serialized_floating_ip, 'create_floating_ip'))
# Push instance floating IPs
_tasks.append(core_tasks.BackendMethodTask().si(serialized_instance, 'push_instance_floating_ips'))
# Wait for operation completion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(core_tasks.PollRuntimeStateTask().si(
core_utils.serialize_instance(floating_ip),
backend_pull_method='pull_floating_ip_runtime_state',
success_state='ACTIVE',
erred_state='ERRED',
).set(countdown=5 if not index else 0))
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant:
serialized_executor = core_utils.serialize_class(openstack_executors.TenantPullFloatingIPsExecutor)
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.ExecutorTask().si(serialized_executor, serialized_tenant))
return _tasks
def get_release_floating_ips_tasks(cls, instance, release_floating_ips):
_tasks = []
if release_floating_ips:
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(
core_tasks.BackendMethodTask()
.si(
core_utils.serialize_instance(floating_ip),
'delete_floating_ip',
)
.set(countdown=5 if not index else 0)
)
else:
# pull related floating IPs state after instance deletion
for index, floating_ip in enumerate(instance.floating_ips):
_tasks.append(
core_tasks.BackendMethodTask()
.si(
core_utils.serialize_instance(floating_ip),
'pull_floating_ip_runtime_state',
)
.set(countdown=5 if not index else 0)
)
shared_tenant = instance.service_project_link.service.settings.scope
if shared_tenant and isinstance(shared_tenant, openstack_models.Tenant):
serialized_tenant = core_utils.serialize_instance(shared_tenant)
_tasks.append(core_tasks.PollStateTask().si(serialized_tenant))
_tasks.append(
openstack_executors.TenantPullFloatingIPsExecutor.as_signature(
shared_tenant
)
)
return _tasks
def test_resource_is_created_when_order_item_is_processed(self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME)
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={
'name':
'item_name',
'description':
'Description',
'schedules': [{
'start': '2021-02-05T10:00:00.000000+00:00',
'end': '2021-02-05T15:00:00.000000+00:00',
}],
},
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.assertTrue(
marketplace_models.Resource.objects.filter(
name='item_name').exists())
resource = marketplace_models.Resource.objects.get(name='item_name')
self.assertEqual(resource.state,
marketplace_models.Resource.States.CREATING)
def trigger_deletion(self):
serialized_order = core_utils.serialize_instance(self.order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.order_item.refresh_from_db()
self.resource.refresh_from_db()
self.volume.refresh_from_db()
def process_role_revoked(sender, structure, user, role, **kwargs):
try:
freeipa_profile = freeipa_models.Profile.objects.get(user=user)
serialized_profile = core_utils.serialize_instance(freeipa_profile)
serialized_structure = core_utils.serialize_instance(structure)
transaction.on_commit(lambda:
tasks.process_role_revoked.delay(serialized_profile, serialized_structure))
except freeipa_models.Profile.DoesNotExist:
pass
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 order_item_process(self, order_item):
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)
order_item.refresh_from_db()
order_item.order.approve()
order_item.order.save()
order_item.resource.scope.set_ok()
def approve_order(order, user):
order.approve()
order.approved_by = user
order.approved_at = timezone.now()
order.save()
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(user)
transaction.on_commit(
lambda: process_order.delay(serialized_order, serialized_user))
def set_state_executing(self, request, uuid=None):
order = self.get_object()
order.approved_by = request.user
order.approved_at = timezone.now()
order.save()
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(request.user)
tasks.process_order.apply_async(args=(serialized_order,
serialized_user))
return self._update_state(request, models.Order.States.EXECUTING,
order)
def update_remote_project_permission(sender, instance, user, **kwargs):
if not settings.WALDUR_AUTH_SOCIAL['ENABLE_EDUTEAMS_SYNC']:
return
transaction.on_commit(
lambda: tasks.update_remote_project_permissions.delay(
serialize_instance(instance.project),
serialize_instance(instance.user),
instance.role,
True,
instance.expiration_time,
))
def test_request_is_deleted(self):
serialized_order = core_utils.serialize_instance(self.order_item.order)
serialized_user = core_utils.serialize_instance(self.fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
self.order_item.refresh_from_db()
self.resource.refresh_from_db()
self.assertEqual(self.order_item.state,
marketplace_models.OrderItem.States.DONE)
self.assertEqual(self.resource.state,
marketplace_models.Resource.States.TERMINATED)
self.assertRaises(ObjectDoesNotExist, self.request.refresh_from_db)
def submit_order_item(self):
fixture = fixtures.ProjectFixture()
offering = marketplace_factories.OfferingFactory(type=PLUGIN_NAME, options={'order': []})
order_item = marketplace_factories.OrderItemFactory(
offering=offering,
attributes={'name': 'item_name', 'description': 'Description'}
)
serialized_order = core_utils.serialize_instance(order_item.order)
serialized_user = core_utils.serialize_instance(fixture.staff)
marketplace_tasks.process_order(serialized_order, serialized_user)
return order_item
def approve(self, request, uuid=None):
order = self.get_object()
order.approve()
order.approved_by = request.user
order.approved_at = timezone.now()
order.save()
serialized_order = core_utils.serialize_instance(order)
serialized_user = core_utils.serialize_instance(request.user)
tasks.process_order.delay(serialized_order, serialized_user)
tasks.create_order_pdf.delay(order.pk)
return Response({'detail': _('Order has been approved.')},
status=status.HTTP_200_OK)
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 get_plan_for_resource(resource, offering):
tenant = resource.service_settings.scope
if not tenant:
logger.warning(
'Skipping billing for resource because it does not have shared OpenStack settings. '
'Resource: %s',
serialize_instance(resource),
)
return
try:
package = package_models.OpenStackPackage.objects.get(tenant=tenant)
except package_models.OpenStackPackage.DoesNotExist:
logger.warning(
'Skipping billing for resource because package for tenant is not defined. '
'Tenant ID: %s',
tenant.id,
)
return
try:
plan = marketplace_models.Plan.objects.get(scope=package.template,
offering=offering)
except marketplace_models.Plan.DoesNotExist:
logger.warning(
'Skipping billing for resource because plan for template is not defined. '
'Template ID: %s',
package.template,
)
return
return plan
