def image_field_data(request, include_empty_option=False):
"""Returns a list of tuples of all images.
Generates a sorted list of images available. And returns a list of
(id, name) tuples.
:param request: django http request object
:param include_empty_option: flag to include a empty tuple in the front of
the list
:return: list of (id, name) tuples
"""
try:
images = get_available_images(request, request.user.project_id)
except Exception:
exceptions.handle(request, _("Unable to retrieve images"))
images.sort(key=lambda c: c.name)
images_list = [("", _("Select Image"))]
for image in images:
image_label = u"{} ({})".format(image.name, sizeformat.diskgbformat(image.size))
images_list.append((image.id, image_label))
if not images:
return [("", _("No images available"))]
return images_list
def image_field_data(request, include_empty_option=False):
"""Returns a list of tuples of all images.
Generates a sorted list of images available. And returns a list of
(id, name) tuples.
:param request: django http request object
:param include_empty_option: flag to include a empty tuple in the front of
the list
:return: list of (id, name) tuples
"""
try:
images = get_available_images(request, request.user.project_id)
except Exception:
exceptions.handle(request, _('Unable to retrieve images'))
images.sort(key=lambda c: c.name)
images_list = [('', _('Select Image'))]
for image in images:
image_label = u"{} ({})".format(image.name,
sizeformat.diskgbformat(image.size))
images_list.append((image.id, image_label))
if not images:
return [
("", _("No images available")),
]
return images_list
def get_size(instance):
if hasattr(instance, "full_flavor"):
size_string = _("%(RAM)s RAM | %(VCPU)s VCPU | %(disk)s Disk")
vals = {'RAM': sizeformat.mbformat(instance.full_flavor.ram),
'VCPU': instance.full_flavor.vcpus,
'disk': sizeformat.diskgbformat(instance.full_flavor.disk)}
return size_string % vals
return _("Not available")
def get_size(instance):
if hasattr(instance, "full_flavor"):
size_string = _("%(RAM)s RAM | %(VCPU)s VCPU | %(disk)s Disk")
vals = {'RAM': sizeformat.mbformat(instance.full_flavor.ram),
'VCPU': instance.full_flavor.vcpus,
'disk': sizeformat.diskgbformat(instance.full_flavor.disk)}
return size_string % vals
return _("Not available")
def get_size(instance):
if hasattr(instance, "full_flavor"):
size_string = _("%(name)s<br>%(RAM)s RAM<br>%(VCPU)s VCPU"
"<br>%(disk)s Disk")
vals = {'name': instance.full_flavor.name,
'RAM': sizeformat.mbformat(instance.full_flavor.ram),
'VCPU': instance.full_flavor.vcpus,
'disk': sizeformat.diskgbformat(instance.full_flavor.disk)}
return mark_safe(size_string % vals)
return _("Not available")
def get_size(instance):
if hasattr(instance, 'properties'):
size_string = _("%(name)s | %(ram)s RAM | %(cpus)s VCPU "
"| %(disk)s Disk")
vals = {'name': instance.properties['id'],
'ram': sizeformat.mbformat(instance.properties['ram']),
'cpus': instance.properties['cpus'],
'disk': sizeformat.diskgbformat(instance.properties['disk'])}
return size_string % vals
return _("Not available")
def get_size(instance):
if hasattr(instance, "full_flavor"):
size_string = _("%(name)s | %(RAM)s RAM | %(VCPU)s VCPU " "| %(disk)s Disk")
vals = {
"name": instance.full_flavor.name,
"RAM": sizeformat.mbformat(instance.full_flavor.ram),
"VCPU": instance.full_flavor.vcpus,
"disk": sizeformat.diskgbformat(instance.full_flavor.disk),
}
return size_string % vals
return _("Not available")
def get_size(instance):
if hasattr(instance, 'properties'):
size_string = _("%(name)s | %(ram)s RAM | %(cpus)s VCPU "
"| %(disk)s Disk")
vals = {
'name': instance.properties['id'],
'ram': sizeformat.mbformat(instance.properties['ram']),
'cpus': instance.properties['cpus'],
'disk': sizeformat.diskgbformat(instance.properties['disk'])
}
return size_string % vals
return _("Not available")
def get_size(instance):
if hasattr(instance, "full_flavor"):
template_name = 'project/instances/_instance_flavor.html'
size_ram = sizeformat.mb_float_format(instance.full_flavor.ram)
if instance.full_flavor.disk > 0:
size_disk = sizeformat.diskgbformat(instance.full_flavor.disk)
else:
size_disk = _("%s GB") % "0"
context = {
"name": instance.full_flavor.name,
"id": instance.id,
"size_disk": size_disk,
"size_ram": size_ram,
"vcpus": instance.full_flavor.vcpus
}
return template.loader.render_to_string(template_name, context)
return _("Not available")
def get_size(instance):
if hasattr(instance, "full_flavor"):
template_name = 'project/instances/_instance_flavor.html'
size_ram = sizeformat.mb_float_format(instance.full_flavor.ram)
if instance.full_flavor.disk > 0:
size_disk = sizeformat.diskgbformat(instance.full_flavor.disk)
else:
size_disk = _("%s GB") % "0"
context = {
"name": instance.full_flavor.name,
"id": instance.id,
"size_disk": size_disk,
"size_ram": size_ram,
"vcpus": instance.full_flavor.vcpus
}
return template.loader.render_to_string(template_name, context)
return _("Not available")
def get_size(instance):
if hasattr(instance, 'full_flavor'):
template_name = 'project/instances/_instance_flavor.html'
f = instance.full_flavor
size_ram = sizeformat.mb_float_format(get_property(f, 'ram'))
if get_property(f, 'disk') > 0:
size_disk = sizeformat.diskgbformat(get_property(f, 'disk'))
else:
size_disk = _("%s GB") % "0"
context = {
'name': get_property(f, 'name'),
'id': instance.id,
'size_disk': size_disk,
'size_ram': size_ram,
'vcpus': get_property(f, 'vcpus'),
'flavor_id': get_property(f, 'id')
}
return template.loader.render_to_string(template_name, context)
return _("Not available")
def get_size(instance):
if hasattr(instance, 'full_flavor'):
template_name = 'project/instances/_instance_flavor.html'
f = instance.full_flavor
size_ram = sizeformat.mb_float_format(get_property(f, 'ram'))
if get_property(f, 'disk') > 0:
size_disk = sizeformat.diskgbformat(get_property(f, 'disk'))
else:
size_disk = _("%s GB") % "0"
context = {
'name': get_property(f, 'name'),
'id': instance.id,
'size_disk': size_disk,
'size_ram': size_ram,
'vcpus': get_property(f, 'vcpus'),
'flavor_id': get_property(f, 'id')
}
return template.loader.render_to_string(template_name, context)
return _("Not available")
def get_volume_size(instance):
if hasattr(instance, "volume"):
return sizeformat.diskgbformat(instance.volume.get("size"))
return _("Not available")
def _test_usage(self, nova_stu_enabled=True, tenant_deleted=False,
overview_days_range=1):
self._stub_api_calls(nova_stu_enabled)
api.nova.extension_supported(
'SimpleTenantUsage', IsA(http.HttpRequest)) \
.AndReturn(nova_stu_enabled)
usage_list = [api.nova.NovaUsage(u) for u in self.usages.list()]
if tenant_deleted:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([[self.tenants.first()], False])
else:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([self.tenants.list(), False])
if nova_stu_enabled:
start_day, now = self._get_start_end_range(overview_days_range)
api.nova.usage_list(IsA(http.HttpRequest),
datetime.datetime(start_day.year,
start_day.month,
start_day.day, 0, 0, 0, 0),
datetime.datetime(now.year,
now.month,
now.day, 23, 59, 59, 0)) \
.AndReturn(usage_list)
self.mox.ReplayAll()
res = self.client.get(reverse('horizon:admin:overview:index'))
self.assertTemplateUsed(res, 'admin/overview/usage.html')
self.assertIsInstance(res.context['usage'], usage.GlobalUsage)
self.assertEqual(nova_stu_enabled,
res.context['simple_tenant_usage_enabled'])
usage_table = encoding.smart_str(u'''
<tr class="" data-object-id="1" id="global_usage__row__1">
<td class="sortable normal_column">test_tenant</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[0].vcpus,
sizeformat.diskgbformat(usage_list[0].local_gb),
sizeformat.mb_float_format(usage_list[0].memory_mb),
usage_list[0].vcpu_hours,
usage_list[0].disk_gb_hours,
usage_list[0].memory_mb_hours)
)
# test for deleted project
usage_table_deleted = encoding.smart_str(u'''
<tr class="" data-object-id="3" id="global_usage__row__3">
<td class="sortable normal_column">3 (Deleted)</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[1].vcpus,
sizeformat.diskgbformat(usage_list[1].local_gb),
sizeformat.mb_float_format(usage_list[1].memory_mb),
usage_list[1].vcpu_hours,
usage_list[1].disk_gb_hours,
usage_list[1].memory_mb_hours)
)
if nova_stu_enabled:
self.assertContains(res, usage_table, html=True)
if tenant_deleted:
self.assertContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table, html=True)
def get_volume_size(instance):
if hasattr(instance, "volume"):
return sizeformat.diskgbformat(instance.volume.get("size"))
return _("Not available")
def get_local_used(hypervisor):
return sizeformat.diskgbformat(hypervisor.local_gb_used)
def _test_usage(self,
nova_stu_enabled=True,
tenant_deleted=False,
overview_days_range=1):
usage_list = [api.nova.NovaUsage(u) for u in self.usages.list()]
if tenant_deleted:
self.mock_tenant_list.return_value = [[self.tenants.first()],
False]
else:
self.mock_tenant_list.return_value = [self.tenants.list(), False]
self.mock_usage_list.return_value = usage_list
res = self.client.get(reverse('horizon:admin:overview:index'))
self.assertTemplateUsed(res, 'admin/overview/usage.html')
self.assertIsInstance(res.context['usage'], usage.GlobalUsage)
self.assertEqual(nova_stu_enabled,
res.context['simple_tenant_usage_enabled'])
usage_table = encoding.smart_str('''
<tr class="" data-object-id="1" id="global_usage__row__1">
<td class="sortable normal_column">test_tenant</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[0].vcpus,
sizeformat.diskgbformat(usage_list[0].local_gb),
sizeformat.mb_float_format(
usage_list[0].memory_mb), usage_list[0].vcpu_hours,
usage_list[0].disk_gb_hours, usage_list[0].memory_mb_hours))
# test for deleted project
usage_table_deleted = encoding.smart_str('''
<tr class="" data-object-id="3" id="global_usage__row__3">
<td class="sortable normal_column">3 (Deleted)</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[1].vcpus,
sizeformat.diskgbformat(usage_list[1].local_gb),
sizeformat.mb_float_format(
usage_list[1].memory_mb), usage_list[1].vcpu_hours,
usage_list[1].disk_gb_hours, usage_list[1].memory_mb_hours))
if nova_stu_enabled:
self.assertContains(res, usage_table, html=True)
if tenant_deleted:
self.assertContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table, html=True)
self.mock_tenant_list.assert_called_once_with(test.IsHttpRequest())
if nova_stu_enabled:
start_day, now = self._get_start_end_range(overview_days_range)
self.mock_usage_list.assert_called_once_with(
test.IsHttpRequest(),
datetime.datetime(start_day.year, start_day.month,
start_day.day, 0, 0, 0, 0),
datetime.datetime(now.year, now.month, now.day, 23, 59, 59, 0))
else:
self.mock_usage_list.assert_not_called()
def _test_usage(self, nova_stu_enabled=True, tenant_deleted=False):
self._stub_api_calls(nova_stu_enabled)
api.nova.extension_supported(
'SimpleTenantUsage', IsA(http.HttpRequest)) \
.AndReturn(nova_stu_enabled)
now = timezone.now()
usage_list = [api.nova.NovaUsage(u) for u in self.usages.list()]
if tenant_deleted:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([[self.tenants.first()], False])
else:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([self.tenants.list(), False])
if nova_stu_enabled:
api.nova.usage_list(IsA(http.HttpRequest),
datetime.datetime(now.year,
now.month,
1, 0, 0, 0, 0),
datetime.datetime(now.year,
now.month,
now.day, 23, 59, 59, 0)) \
.AndReturn(usage_list)
api.nova.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.limits['absolute'])
api.neutron.is_extension_supported(IsA(http.HttpRequest),
'security-group').AndReturn(True)
api.network.floating_ip_supported(IsA(http.HttpRequest)) \
.AndReturn(True)
api.network.tenant_floating_ip_list(IsA(http.HttpRequest)) \
.AndReturn(self.floating_ips.list())
api.network.security_group_list(IsA(http.HttpRequest)) \
.AndReturn(self.q_secgroups.list())
api.cinder.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.cinder_limits['absolute'])
self.mox.ReplayAll()
res = self.client.get(reverse('horizon:admin:overview:index'))
self.assertTemplateUsed(res, 'admin/overview/usage.html')
self.assertTrue(isinstance(res.context['usage'], usage.GlobalUsage))
self.assertEqual(nova_stu_enabled,
res.context['simple_tenant_usage_enabled'])
usage_table = encoding.smart_str(
u'''
<tr class="" data-object-id="1" id="global_usage__row__1">
<td class="sortable normal_column">test_tenant</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' %
(usage_list[0].vcpus,
sizeformat.diskgbformat(usage_list[0].disk_gb_hours),
sizeformat.mb_float_format(usage_list[0].memory_mb),
usage_list[0].vcpu_hours, usage_list[0].total_local_gb_usage,
usage_list[0].memory_mb_hours))
# test for deleted project
usage_table_deleted = encoding.smart_str(
u'''
<tr class="" data-object-id="3" id="global_usage__row__3">
<td class="sortable normal_column">3 (Deleted)</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' %
(usage_list[1].vcpus,
sizeformat.diskgbformat(usage_list[1].disk_gb_hours),
sizeformat.mb_float_format(usage_list[1].memory_mb),
usage_list[1].vcpu_hours, usage_list[1].total_local_gb_usage,
usage_list[1].memory_mb_hours))
if nova_stu_enabled:
self.assertContains(res, usage_table, html=True)
if tenant_deleted:
self.assertContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table, html=True)
def _test_usage(self, nova_stu_enabled=True, tenant_deleted=False):
self._stub_api_calls(nova_stu_enabled)
api.nova.extension_supported(
'SimpleTenantUsage', IsA(http.HttpRequest)) \
.AndReturn(nova_stu_enabled)
now = timezone.now()
usage_list = [api.nova.NovaUsage(u) for u in self.usages.list()]
if tenant_deleted:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([[self.tenants.first()], False])
else:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([self.tenants.list(), False])
if nova_stu_enabled:
api.nova.usage_list(IsA(http.HttpRequest),
datetime.datetime(now.year,
now.month,
1, 0, 0, 0, 0),
datetime.datetime(now.year,
now.month,
now.day, 23, 59, 59, 0)) \
.AndReturn(usage_list)
api.nova.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.limits['absolute'])
api.neutron.is_extension_supported(IsA(http.HttpRequest),
'security-group').AndReturn(True)
api.network.floating_ip_supported(IsA(http.HttpRequest)) \
.AndReturn(True)
api.network.tenant_floating_ip_list(IsA(http.HttpRequest)) \
.AndReturn(self.floating_ips.list())
api.network.security_group_list(IsA(http.HttpRequest)) \
.AndReturn(self.q_secgroups.list())
api.cinder.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.cinder_limits['absolute'])
self.mox.ReplayAll()
res = self.client.get(reverse('horizon:admin:overview:index'))
self.assertTemplateUsed(res, 'admin/overview/usage.html')
self.assertTrue(isinstance(res.context['usage'], usage.GlobalUsage))
self.assertEqual(nova_stu_enabled,
res.context['simple_tenant_usage_enabled'])
usage_table = encoding.smart_str(u'''
<tr class="" data-object-id="1" id="global_usage__row__1">
<td class="sortable normal_column">test_tenant</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[0].vcpus,
sizeformat.diskgbformat(usage_list[0].local_gb),
sizeformat.mb_float_format(usage_list[0].memory_mb),
usage_list[0].vcpu_hours,
usage_list[0].disk_gb_hours,
usage_list[0].memory_mb_hours)
)
# test for deleted project
usage_table_deleted = encoding.smart_str(u'''
<tr class="" data-object-id="3" id="global_usage__row__3">
<td class="sortable normal_column">3 (Deleted)</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' % (usage_list[1].vcpus,
sizeformat.diskgbformat(usage_list[1].local_gb),
sizeformat.mb_float_format(usage_list[1].memory_mb),
usage_list[1].vcpu_hours,
usage_list[1].disk_gb_hours,
usage_list[1].memory_mb_hours)
)
if nova_stu_enabled:
self.assertContains(res, usage_table, html=True)
if tenant_deleted:
self.assertContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table, html=True)
def get_local_used(hypervisor):
return sizeformat.diskgbformat(hypervisor.local_gb_used)
def __init__(self, curr_val, max_val, curr_update, max_update):
super(StorageValues, self).__init__(curr_val, max_val, curr_update, max_update)
self.currUnits = sizeformat.diskgbformat(curr_val)
self.maxUnits = sizeformat.diskgbformat(max_val)
