def test_create_volume_number_over_alloted_quota(self):
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': len(self.volumes.list())}
formData = {'name': u'Too Many...',
'description': u'We have no volumes left!',
'method': u'CreateForm',
'size': 10}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
expected_error = [u'You are already using all of your available'
' volumes.']
self.assertEqual(res.context['form'].errors['__all__'], expected_error)
def test_create_volume_gb_used_over_alloted_quota(self):
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 80,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
formData = {'name': u'This Volume Is Huge!',
'description': u'This is a volume that is just too big!',
'method': u'CreateForm',
'size': 5000}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
expected_error = [u'A volume of 5000GB cannot be created as you only'
' have 20GB of your quota available.']
self.assertEqual(res.context['form'].errors['__all__'], expected_error)
def test_create_volume_gb_used_over_alloted_quota(self):
usage_limit = {
"maxTotalVolumeGigabytes": 100,
"gigabytesUsed": 80,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
formData = {
"name": u"This Volume Is Huge!",
"description": u"This is a volume that is just too big!",
"method": u"CreateForm",
"size": 5000,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volume_snapshots.list())
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"is_public": True, "status": "active"}
).AndReturn([self.images.list(), False, False])
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"property-owner_id": self.tenant.id, "status": "active"}
).AndReturn([[], False, False])
cinder.volume_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volumes.list())
cinder.extension_supported(IsA(http.HttpRequest), "AvailabilityZones").AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post(url, formData)
expected_error = [u"A volume of 5000GB cannot be created as you only" " have 20GB of your quota available."]
self.assertEqual(res.context["form"].errors["__all__"], expected_error)
def test_create_volume_number_over_alloted_quota(self):
usage_limit = {
"maxTotalVolumeGigabytes": 100,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": len(self.cinder_volumes.list()),
}
formData = {
"name": u"Too Many...",
"description": u"We have no volumes left!",
"method": u"CreateForm",
"size": 10,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volume_snapshots.list())
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"is_public": True, "status": "active"}
).AndReturn([self.images.list(), False, False])
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"property-owner_id": self.tenant.id, "status": "active"}
).AndReturn([[], False, False])
cinder.volume_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volumes.list())
cinder.extension_supported(IsA(http.HttpRequest), "AvailabilityZones").AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post(url, formData)
expected_error = [u"You are already using all of your available" " volumes."]
self.assertEqual(res.context["form"].errors["__all__"], expected_error)
def test_create_volume_from_snapshot_invalid_size(self):
usage_limit = {
"maxTotalVolumeGigabytes": 100,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
snapshot = self.cinder_volume_snapshots.first()
formData = {
"name": u"A Volume I Am Making",
"description": u"This is a volume I am making for a test.",
"method": u"CreateForm",
"size": 20,
"snapshot_source": snapshot.id,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest), str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).AndReturn(self.cinder_volumes.first())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post("?".join([url, "snapshot_id=" + str(snapshot.id)]), formData, follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(res, "form", None, "The volume size cannot be less than the " "snapshot size (40GB)")
def test_create_volume_from_image_under_image_min_disk_size(self):
usage_limit = {
"maxTotalVolumeGigabytes": 100,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
image = self.images.get(name="protected_images")
image.min_disk = 30
formData = {
"name": u"A Volume I Am Making",
"description": u"This is a volume I am making for a test.",
"method": u"CreateForm",
"size": 5,
"image_source": image.id,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest), str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), "AvailabilityZones").AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post("?".join([url, "image_id=" + str(image.id)]), formData, follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(
res, "form", None, "The volume size cannot be less than the " "image minimum disk size (30GB)"
)
def test_create_volume_from_image_under_image_min_disk_size(self):
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
image = self.images.get(name="protected_images")
image.min_disk = 30
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 5, 'image_source': image.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url,
"image_id=" + str(image.id)]),
formData, follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(res, 'form', None,
"The volume size cannot be less than the "
"image minimum disk size (30GB)")
def test_create_volume_from_snapshot_invalid_size(self):
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
snapshot = self.cinder_volume_snapshots.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 20, 'snapshot_source': snapshot.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest),
str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).\
AndReturn(self.cinder_volumes.first())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url,
"snapshot_id=" + str(snapshot.id)]),
formData, follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(res, 'form', None,
"The volume size cannot be less than the "
"snapshot size (40GB)")
def test_create_volume_from_image_dropdown(self):
volume = self.cinder_volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 200,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
image = self.images.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 30,
'type': '',
'volume_source_type': 'image_source',
'snapshot_source': self.cinder_volume_snapshots.first().id,
'image_source': image.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.cinder_volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
cinder.volume_list(IsA(
http.HttpRequest)).AndReturn(self.cinder_volumes.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)) \
.AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=image.id,
availability_zone=None,
source_volid=None).AndReturn(volume)
self.mox.ReplayAll()
# get image from dropdown list
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post(url, formData)
redirect_url = VOLUME_VOLUMES_TAB_URL
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_volume_from_volume(self):
volume = self.volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
formData = {'name': u'A copy of a volume',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'volume_source_type': 'volume_source',
'volume_source': volume.id}
cinder.volume_list(IsA(http.HttpRequest)).\
AndReturn(self.volumes.list())
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_get(IsA(http.HttpRequest),
volume.id).AndReturn(self.volumes.first())
cinder.extension_supported(IsA(http.HttpRequest),
'AvailabilityZones').AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=None,
availability_zone=None,
source_volid=volume.id).AndReturn(volume)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
redirect_url = reverse('horizon:project:volumes:index')
res = self.client.post(url, formData)
self.assertNoFormErrors(res)
self.assertMessageCount(info=1)
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_volume_from_image_dropdown(self):
volume = self.cinder_volumes.first()
usage_limit = {
"maxTotalVolumeGigabytes": 200,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
image = self.images.first()
formData = {
"name": u"A Volume I Am Making",
"description": u"This is a volume I am making for a test.",
"method": u"CreateForm",
"size": 30,
"type": "",
"volume_source_type": "image_source",
"snapshot_source": self.cinder_volume_snapshots.first().id,
"image_source": image.id,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volume_snapshots.list())
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"is_public": True, "status": "active"}
).AndReturn([self.images.list(), False, False])
api.glance.image_list_detailed(
IsA(http.HttpRequest), filters={"property-owner_id": self.tenant.id, "status": "active"}
).AndReturn([[], False, False])
cinder.volume_list(IsA(http.HttpRequest)).AndReturn(self.cinder_volumes.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest), str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), "AvailabilityZones").AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(self.cinder_availability_zones.list())
cinder.volume_create(
IsA(http.HttpRequest),
formData["size"],
formData["name"],
formData["description"],
"",
metadata={},
snapshot_id=None,
image_id=image.id,
availability_zone=None,
source_volid=None,
).AndReturn(volume)
self.mox.ReplayAll()
# get image from dropdown list
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post(url, formData)
redirect_url = VOLUME_VOLUMES_TAB_URL
self.assertRedirectsNoFollow(res, redirect_url)
def test_tenant_limit_usages_cinder_exception(self):
api.base.is_service_enabled(IsA(http.HttpRequest),
'volume').AndReturn(True)
api.nova.tenant_absolute_limits(IsA(http.HttpRequest)).AndReturn({})
api.cinder.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndRaise(cinder.cinder_exception.ClientException('test'))
exceptions.handle(IsA(http.HttpRequest),
_("Unable to retrieve volume limit information."))
self.mox.ReplayAll()
quotas.tenant_limit_usages(self.request)
def test_create_volume_from_snapshot_dropdown(self):
volume = self.volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
snapshot = self.volume_snapshots.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'volume_source_type': 'snapshot_source',
'snapshot_source': snapshot.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest),
str(snapshot.id)).AndReturn(snapshot)
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=snapshot.id,
image_id=None).\
AndReturn(volume)
self.mox.ReplayAll()
# get snapshot from dropdown list
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
redirect_url = reverse('horizon:project:volumes:index')
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_snapshot_get(self):
volume = self.volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create_snapshot',
args=[volume.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/volumes/create_snapshot.html')
def get_context_data(self, **kwargs):
context = super(CreateCGroupView, self).get_context_data(**kwargs)
context["cg_snapshot_id"] = self.kwargs["cg_snapshot_id"]
args = (self.kwargs["cg_snapshot_id"],)
context["submit_url"] = reverse(self.submit_url, args=args)
try:
# get number of volumes we will be creating
cg_snapshot = cinder.volume_cg_snapshot_get(self.request, context["cg_snapshot_id"])
cgroup_id = cg_snapshot.consistencygroup_id
search_opts = {"consistencygroup_id": cgroup_id}
volumes = api.cinder.volume_list(self.request, search_opts=search_opts)
num_volumes = len(volumes)
usages = quotas.tenant_limit_usages(self.request)
if usages["volumesUsed"] + num_volumes > usages["maxTotalVolumes"]:
raise ValueError(_("Unable to create consistency group due to " "exceeding volume quota limit."))
else:
usages["numRequestedItems"] = num_volumes
context["usages"] = usages
except ValueError as e:
exceptions.handle(self.request, e.message)
return None
except Exception:
exceptions.handle(self.request, _("Unable to retrieve consistency " "group information."))
return context
def get_context_data(self, **kwargs):
context = super(CloneGroupView, self).get_context_data(**kwargs)
context['group_id'] = self.kwargs['group_id']
args = (self.kwargs['group_id'],)
context['submit_url'] = reverse(self.submit_url, args=args)
try:
# get number of volumes we will be creating
group_id = context['group_id']
search_opts = {'group_id': group_id}
volumes = api.cinder.volume_list(self.request,
search_opts=search_opts)
num_volumes = len(volumes)
usages = quotas.tenant_limit_usages(self.request)
if usages['totalVolumesUsed'] + num_volumes > \
usages['maxTotalVolumes']:
raise ValueError(_('Unable to create group due to '
'exceeding volume quota limit.'))
else:
usages['numRequestedItems'] = num_volumes
context['usages'] = usages
except ValueError as e:
exceptions.handle(self.request, e.message)
return None
except Exception:
exceptions.handle(self.request,
_('Unable to retrieve group information.'))
return context
def get_context_data(self, **kwargs):
context = super(CreateView, self).get_context_data(**kwargs)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request)
return context
def test_create_volume_from_image(self):
volume = self.volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 200,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
image = self.images.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 40,
'type': '',
'image_source': image.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=image.id,
availability_zone=None,
source_volid=None).AndReturn(volume)
self.mox.ReplayAll()
# get image from url
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url,
"image_id=" + str(image.id)]),
formData)
redirect_url = reverse('horizon:project:volumes:index')
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_snapshot_get(self):
volume = self.volumes.first()
usage_limit = {
'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6
}
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create_snapshot',
args=[volume.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/volumes/create_snapshot.html')
def test_create_volume_from_snapshot(self):
volume = self.cinder_volumes.first()
usage_limit = {
'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6
}
snapshot = self.cinder_volume_snapshots.first()
formData = {
'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'snapshot_source': snapshot.id
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest),
str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).\
AndReturn(self.cinder_volumes.first())
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=snapshot.id,
image_id=None,
availability_zone=None,
source_volid=None).AndReturn(volume)
self.mox.ReplayAll()
# get snapshot from url
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post(
"?".join([url, "snapshot_id=" + str(snapshot.id)]), formData)
redirect_url = reverse('horizon:project:volumes:index')
self.assertRedirectsNoFollow(res, redirect_url)
def get_context_data(self, **kwargs):
context = super(CreateView, self).get_context_data(**kwargs)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
context['volume_types'] = self._get_volume_types()
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(CreateView, self).get_context_data(**kwargs)
try:
context["usages"] = quotas.tenant_limit_usages(self.request)
context["volume_types"] = self._get_volume_types()
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(CreateSnapshotView, self).get_context_data(**kwargs)
context['volume_id'] = self.kwargs['volume_id']
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(self.__class__, self).get_context_data(**kwargs)
context['share_id'] = self.kwargs['share_id']
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request, _('Unable to retrieve quotas.'))
return context
def test_create_volume_dropdown(self):
volume = self.volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6}
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'volume_source_type': 'no_source_type',
'snapshot_source': self.volume_snapshots.first().id,
'image_source': self.images.first().id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=None).\
AndReturn(volume)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
redirect_url = reverse('horizon:project:volumes:index')
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_volume_gb_used_over_alloted_quota(self):
usage_limit = {
'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 80,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6
}
formData = {
'name': u'This Volume Is Huge!',
'description': u'This is a volume that is just too big!',
'method': u'CreateForm',
'size': 5000
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
expected_error = [
u'A volume of 5000GB cannot be created as you only'
' have 20GB of your quota available.'
]
self.assertEqual(res.context['form'].errors['__all__'], expected_error)
def test_create_volume_number_over_alloted_quota(self):
usage_limit = {
'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': len(self.volumes.list())
}
formData = {
'name': u'Too Many...',
'description': u'We have no volumes left!',
'method': u'CreateForm',
'size': 10
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post(url, formData)
expected_error = [
u'You are already using all of your available'
' volumes.'
]
self.assertEqual(res.context['form'].errors['__all__'], expected_error)
def test_extend_volume_with_wrong_size(self):
volume = self.cinder_volumes.first()
usage_limit = {
"maxTotalVolumeGigabytes": 100,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
formData = {"name": u"A Volume I Am Making", "orig_size": volume.size, "new_size": 10}
cinder.volume_get(IsA(http.HttpRequest), volume.id).AndReturn(self.cinder_volumes.first())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse("horizon:project:volumes:volumes:extend", args=[volume.id])
res = self.client.post(url, formData)
self.assertFormError(res, "form", None, "New size must be greater than " "current size.")
def test_create_volume_from_snapshot_invalid_size(self):
usage_limit = {
'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6
}
snapshot = self.volume_snapshots.first()
formData = {
'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 20,
'snapshot_source': snapshot.id
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest),
str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).\
AndReturn(self.volumes.first())
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:create')
res = self.client.post("?".join(
[url, "snapshot_id=" + str(snapshot.id)]),
formData,
follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(
res, 'form', None, "The volume size cannot be less than the "
"snapshot size (40GB)")
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['share'] = self.get_object()
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
args = (self.get_object().id,)
context['submit_url'] = reverse(self.submit_url, args=args)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request)
return context
def test_create_volume_from_snapshot(self):
volume = self.cinder_volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
snapshot = self.cinder_volume_snapshots.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'snapshot_source': snapshot.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest),
str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).\
AndReturn(self.cinder_volumes.first())
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=snapshot.id,
image_id=None,
availability_zone=None,
source_volid=None).AndReturn(volume)
self.mox.ReplayAll()
# get snapshot from url
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url,
"snapshot_id=" + str(snapshot.id)]),
formData)
redirect_url = VOLUME_VOLUMES_TAB_URL
self.assertRedirectsNoFollow(res, redirect_url)
def test_create_volume_from_snapshot(self):
volume = self.cinder_volumes.first()
usage_limit = {
"maxTotalVolumeGigabytes": 250,
"gigabytesUsed": 20,
"volumesUsed": len(self.cinder_volumes.list()),
"maxTotalVolumes": 6,
}
snapshot = self.cinder_volume_snapshots.first()
formData = {
"name": u"A Volume I Am Making",
"description": u"This is a volume I am making for a test.",
"method": u"CreateForm",
"size": 50,
"type": "",
"snapshot_source": snapshot.id,
}
cinder.volume_type_list(IsA(http.HttpRequest)).AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).AndReturn(usage_limit)
cinder.volume_snapshot_get(IsA(http.HttpRequest), str(snapshot.id)).AndReturn(snapshot)
cinder.volume_get(IsA(http.HttpRequest), snapshot.volume_id).AndReturn(self.cinder_volumes.first())
cinder.volume_create(
IsA(http.HttpRequest),
formData["size"],
formData["name"],
formData["description"],
"",
metadata={},
snapshot_id=snapshot.id,
image_id=None,
availability_zone=None,
source_volid=None,
).AndReturn(volume)
self.mox.ReplayAll()
# get snapshot from url
url = reverse("horizon:project:volumes:volumes:create")
res = self.client.post("?".join([url, "snapshot_id=" + str(snapshot.id)]), formData)
redirect_url = VOLUME_VOLUMES_TAB_URL
self.assertRedirectsNoFollow(res, redirect_url)
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context["volume"] = self.get_object()
try:
usages = quotas.tenant_limit_usages(self.request)
usages["gigabytesUsed"] = usages["gigabytesUsed"] - context["volume"].size
context["usages"] = usages
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['share'] = self.get_object()
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request)
return context
def test_create_snapshot_get(self):
volume = self.cinder_volumes.first()
cinder.volume_get(IsA(http.HttpRequest), volume.id) \
.AndReturn(volume)
snapshot_used = len(self.cinder_volume_snapshots.list())
usage_limit = {'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'snapshotsUsed': snapshot_used,
'maxTotalSnapshots': 6}
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:storage:volumes:'
'volumes:create_snapshot', args=[volume.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'storage/volumes/volumes/'
'create_snapshot.html')
def test_create_volume_from_image_under_image_size(self):
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
image = self.images.first()
formData = {'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 1, 'image_source': image.id}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url,
"image_id=" + str(image.id)]),
formData, follow=True)
self.assertEqual(res.redirect_chain, [])
# in django 1.6 filesizeformat replaces all spaces with
# non-breaking space characters
if django.VERSION >= (1, 6):
msg = (u"The volume size cannot be less than the "
u"image size (20.0\xa0GB)")
else:
msg = (u"The volume size cannot be less than the "
u"image size (20.0 GB)")
self.assertFormError(res, 'form', None, msg)
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['volume'] = self.get_object()
args = (self.kwargs['volume_id'], )
context['submit_url'] = reverse(self.submit_url, args=args)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
_volume_types = self._get_volume_types()
_volumes = cinder.volume_list(self.request)
_snapshots = cinder.volume_snapshot_list(self.request)
volume_types = {}
volume_type_size = {}
for volume_type in _volume_types:
if volume_type['name'] == 'no_type':
continue
volume_type_size[volume_type['name']] = 0
for volume in _volumes:
volume_types[volume.id] = volume.volume_type
volume_type_size[volume.volume_type] = (volume_type_size.get(
volume.volume_type) or 0) + volume.size
for snapshot in cinder.volume_snapshot_list(self.request):
volume_type_size[volume_types[snapshot.volume_id]] = (
volume_type_size.get(volume_types.get(snapshot.volume_id))
or 0) + snapshot.size
tenant_quotas = {}
for quota in cinder.tenant_quota_get(self.request,
self.request.user.tenant_id):
if quota.name.startswith('gigabytes_'):
tenant_quotas[quota.name[10:]] = quota.limit
volume_type_usage = []
for volume_type, total_size in volume_type_size.iteritems():
volume_type_usage.append({
'name':
volume_type,
'usage':
total_size,
'quota':
tenant_quotas.get(volume_type) or -1
})
context['usages']['volume_type'] = volume_type_usage
context['volume_types'] = json.dumps(_volume_types)
except Exception:
exceptions.handle(self.request)
print "#" * 120
print context
return context
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['volume'] = self.get_object()
try:
usages = quotas.tenant_limit_usages(self.request)
usages['gigabytesUsed'] = (usages['gigabytesUsed']
- context['volume'].size)
context['usages'] = usages
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
if common_utils.need_ticket(self.request):
self.modal_header = _("Apply Volume")
self.submit_label = _("Apply Volume")
context = super(CreateView, self).get_context_data(**kwargs)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
context['volume_types'] = self._get_volume_types()
except Exception:
exceptions.handle(self.request)
return context
def test_tenant_limit_usages_cinder_exception(self):
self.mock_is_service_enabled.retrieve = False
self.mock_is_volume_service_enabled.return_value = True
self.mock_tenant_absolute_limits.side_effect = \
cinder.cinder_exception.ClientException('test')
quotas.tenant_limit_usages(self.request)
self.mock_is_service_enabled.assert_called_once_with(
test.IsHttpRequest(), 'compute')
self.mock_is_volume_service_enabled.assert_called_once_with(
test.IsHttpRequest())
self.mock_tenant_absolute_limits.assert_called_once_with(
test.IsHttpRequest())
self.mock_handle.assert_has_calls([
mock.call(test.IsHttpRequest(),
_("Unable to retrieve compute limit information.")),
mock.call(test.IsHttpRequest(),
_("Unable to retrieve volume limit information.")),
])
self.assertEqual(2, self.mock_handle.call_count)
def test_create_volume_from_image_under_image_min_disk_size(self):
usage_limit = {
'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6
}
image = self.images.get(name="protected_images")
image.min_disk = 30
formData = {
'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 5,
'image_source': image.id
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post("?".join([url, "image_id=" + str(image.id)]),
formData,
follow=True)
self.assertEqual(res.redirect_chain, [])
self.assertFormError(
res, 'form', None, "The volume size cannot be less than the "
"image minimum disk size (30GB)")
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['volume'] = self.get_object()
args = (self.kwargs['volume_id'],)
context['submit_url'] = reverse(self.submit_url, args=args)
try:
usages = quotas.tenant_limit_usages(self.request)
usages['gigabytesUsed'] = (usages['gigabytesUsed']
- context['volume'].size)
context['usages'] = usages
except Exception:
exceptions.handle(self.request)
return context
def get_context_data(self, **kwargs):
context = super(ExtendView, self).get_context_data(**kwargs)
context['volume'] = self.get_object()
args = (self.kwargs['volume_id'], )
context['submit_url'] = reverse(self.submit_url, args=args)
try:
usages = quotas.tenant_limit_usages(self.request)
usages['totalGigabytesUsed'] = (usages['totalGigabytesUsed'] -
context['volume'].size)
context['usages'] = usages
except Exception:
exceptions.handle(self.request)
return context
def test_extend_volume_with_wrong_size(self):
volume = self.cinder_volumes.first()
usage_limit = {'maxTotalVolumeGigabytes': 100,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6}
formData = {'name': u'A Volume I Am Making',
'orig_size': volume.size,
'new_size': 10}
cinder.volume_get(IsA(http.HttpRequest), volume.id).\
AndReturn(self.cinder_volumes.first())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:extend',
args=[volume.id])
res = self.client.post(url, formData)
self.assertFormError(res, 'form', None,
"New size for extend must be greater than "
"current size.")
def test_create_snapshot_get(self):
volume = self.cinder_volumes.first()
cinder.volume_get(IsA(http.HttpRequest), volume.id) \
.AndReturn(volume)
snapshot_used = len(self.cinder_volume_snapshots.list())
usage_limit = {
'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'snapshotsUsed': snapshot_used,
'maxTotalSnapshots': 6
}
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
self.mox.ReplayAll()
url = reverse('horizon:virtual:volumes:'
'volumes:create_snapshot',
args=[volume.id])
res = self.client.get(url)
self.assertTemplateUsed(
res, 'virtual/volumes/volumes/'
'create_snapshot.html')
def get_context_data(self, **kwargs):
context = super(CreateSnapshotAdvancedView,
self).get_context_data(**kwargs)
instance_id = self.kwargs['instance_id']
context['instance_id'] = instance_id
context['attached'] = True
context['submit_url'] = reverse(self.submit_url, args=[instance_id])
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request,
_('Unable to retrieve tenant quota infomation.'))
context['usages'] = {}
return context
def clean(self):
cleaned_data = super(ExtendForm, self).clean()
new_size = cleaned_data.get('new_size')
orig_size = self.initial['orig_size']
if new_size <= orig_size:
raise ValidationError(
_("New size must be greater than current size."))
usages = quotas.tenant_limit_usages(self.request)
availableGB = usages['maxTotalVolumeGigabytes'] - \
usages['gigabytesUsed']
if availableGB < (new_size - orig_size):
message = _('Volume cannot be extended to %(req)iGB as '
'you only have %(avail)iGB of your quota '
'available.')
params = {'req': new_size, 'avail': availableGB}
self._errors["new_size"] = self.error_class([message % params])
return cleaned_data
def get_context_data(self, **kwargs):
context = super(CreateSnapshotView, self).get_context_data(**kwargs)
context['volume_id'] = self.kwargs['volume_id']
try:
volume = cinder.volume_get(self.request, context['volume_id'])
if (volume.status == 'in-use'):
context['attached'] = True
context['form'].set_warning(_("This volume is currently "
"attached to an instance. "
"In some cases, creating a "
"snapshot from an attached "
"volume can result in a "
"corrupted snapshot."))
context['usages'] = quotas.tenant_limit_usages(self.request)
except Exception:
exceptions.handle(self.request,
_('Unable to retrieve volume information.'))
return context
def clean(self):
cleaned_data = super(ExtendForm, self).clean()
new_size = cleaned_data.get('new_size')
orig_size = self.initial['orig_size']
if new_size <= orig_size:
error_msg = _("New size must be greater than current size.")
self._errors['new_size'] = self.error_class([error_msg])
return cleaned_data
usages = quotas.tenant_limit_usages(self.request)
availableGB = usages['maxTotalVolumeGigabytes'] - \
usages['totalGigabytesUsed']
if availableGB < (new_size - orig_size):
message = _('Volume cannot be extended to %(req)iGiB as '
'the maximum size it can be extended to is '
'%(max_size)iGiB.')
params = {'req': new_size, 'max_size': (availableGB + orig_size)}
self._errors["new_size"] = self.error_class([message % params])
return cleaned_data
def get_quota(request):
usages = quotas.tenant_quota_usages(request)
hdd_usages = quotas.tenant_limit_usages(request)
available_float_ip = usages['floating_ips']['available']
availableGB = hdd_usages['maxTotalVolumeGigabytes'] - hdd_usages[
'totalVolumeGigabytesUsed']
availableVol = hdd_usages['maxTotalVolumes'] - hdd_usages[
'totalVolumesUsed']
available_count = usages['instances']['available']
available_cores = usages['cores']['available']
available_ram = usages['ram']['available']
return {
'count': available_count,
'vcpus': available_cores,
'memory': available_ram,
'float_ip': available_float_ip,
'hdd_count': availableVol,
'hdd': availableGB,
}
def clean(self):
cleaned_data = super(ExtendForm, self).clean()
new_size = cleaned_data.get('new_size')
orig_size = self.initial['orig_size']
if new_size <= orig_size:
error_msg = _("New size must be greater than current size.")
self._errors['new_size'] = self.error_class([error_msg])
return cleaned_data
usages = quotas.tenant_limit_usages(self.request)
availableGB = usages['maxTotalVolumeGigabytes'] - \
usages['gigabytesUsed']
if availableGB < (new_size -
orig_size) or new_size > VOLUME_SIZE_LIMIT:
message = _(
'Volume cannot be extended to %(req)iGB, as per Expostack policy total volume size should be less than %s GB.'
'Please contact [email protected] for any queries.'
) % VOLUME_SIZE_LIMIT
params = {'req': new_size, 'avail': availableGB}
self._errors["new_size"] = self.error_class([message % params])
return cleaned_data
def get_context_data(self, **kwargs):
context = super(CreateView, self).get_context_data(**kwargs)
try:
context['usages'] = quotas.tenant_limit_usages(self.request)
volume_types = cinder.volume_type_list(self.request)
#decorate types with info from settings
tmeta = getattr(settings, 'VOLUME_TYPE_META', {})
types = []
for t in volume_types:
type = {}
type['name'] = t.name
type['usage'] = tmeta[
t.name]['usage'] if t.name in tmeta else 'None'
type['iops'] = tmeta[
t.name]['iops'] if t.name in tmeta else 'None'
type['throughput'] = tmeta[
t.name]['throughput'] if t.name in tmeta else 'None'
types.append(type)
context['types'] = json.dumps(types)
context['typenames'] = [t.name for t in volume_types]
context['volume_types'] = self._get_volume_types()
except Exception:
exceptions.handle(self.request)
return context
def get_help_text(self, extra_context=None):
extra = {} if extra_context is None else dict(extra_context)
try:
extra['usages'] = quotas.tenant_limit_usages(self.request)
extra['usages_json'] = json.dumps(extra['usages'])
extra['cinder_enabled'] = \
base.is_service_enabled(self.request, 'volume')
flavors = json.dumps([f._info for f in
instance_utils.flavor_list(self.request)])
extra['flavors'] = flavors
images = image_utils.get_available_images(
self.request, self.initial['project_id'], self._images_cache)
if images is not None:
attrs = [{'id': i.id,
'min_disk': getattr(i, 'min_disk', 0),
'min_ram': getattr(i, 'min_ram', 0),
'size': functions.bytes_to_gigabytes(i.size)}
for i in images]
extra['images'] = json.dumps(attrs)
except Exception:
exceptions.handle(self.request,
_("Unable to retrieve quota information."))
return super(SetInstanceDetailsAction, self).get_help_text(extra)
def get_context_data(self, **kwargs):
context = super(CreateCGroupView, self).get_context_data(**kwargs)
context['cg_snapshot_id'] = self.kwargs['cg_snapshot_id']
args = (self.kwargs['cg_snapshot_id'], )
context['submit_url'] = reverse(self.submit_url, args=args)
try:
# get number of volumes we will be creating
cg_snapshot = cinder.volume_cg_snapshot_get(
self.request, context['cg_snapshot_id'])
cgroup_id = cg_snapshot.consistencygroup_id
search_opts = {'consistencygroup_id': cgroup_id}
volumes = api.cinder.volume_list(self.request,
search_opts=search_opts)
num_volumes = len(volumes)
usages = quotas.tenant_limit_usages(self.request)
if usages['volumesUsed'] + num_volumes > \
usages['maxTotalVolumes']:
raise ValueError(
_('Unable to create consistency group due to '
'exceeding volume quota limit.'))
else:
usages['numRequestedItems'] = num_volumes
context['usages'] = usages
except ValueError as e:
exceptions.handle(self.request, e.message)
return None
except Exception:
exceptions.handle(
self.request,
_('Unable to retrieve consistency '
'group information.'))
return context
def test_create_volume_from_image_dropdown(self):
volume = self.cinder_volumes.first()
usage_limit = {
'maxTotalVolumeGigabytes': 200,
'gigabytesUsed': 20,
'volumesUsed': len(self.cinder_volumes.list()),
'maxTotalVolumes': 6
}
image = self.images.first()
formData = {
'name': u'A Volume I Am Making',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 30,
'type': '',
'volume_source_type': 'image_source',
'snapshot_source': self.cinder_volume_snapshots.first().id,
'image_source': image.id
}
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.cinder_volume_snapshots.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False, False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False, False])
cinder.volume_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_volumes.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)) \
.AndReturn(usage_limit)
api.glance.image_get(IsA(http.HttpRequest),
str(image.id)).AndReturn(image)
cinder.extension_supported(IsA(http.HttpRequest), 'AvailabilityZones')\
.AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=image.id,
availability_zone=None,
source_volid=None).AndReturn(volume)
self.mox.ReplayAll()
# get image from dropdown list
url = reverse('horizon:project:volumes:volumes:create')
res = self.client.post(url, formData)
redirect_url = VOLUME_VOLUMES_TAB_URL
self.assertRedirectsNoFollow(res, redirect_url)
def handle(self, request, data):
try:
usages = quotas.tenant_limit_usages(self.request)
availableGB = usages['maxTotalVolumeGigabytes'] - \
usages['gigabytesUsed']
availableVol = usages['maxTotalVolumes'] - usages['volumesUsed']
snapshot_id = None
image_id = None
source_type = data.get('volume_source_type', None)
if (data.get("snapshot_source", None)
and source_type in [None, 'snapshot_source']):
# Create from Snapshot
snapshot = self.get_snapshot(request, data["snapshot_source"])
snapshot_id = snapshot.id
if (data['size'] < snapshot.size):
error_message = _('The volume size cannot be less than '
'the snapshot size (%sGB)' %
snapshot.size)
raise ValidationError(error_message)
elif (data.get("image_source", None)
and source_type in [None, 'image_source']):
# Create from Snapshot
image = self.get_image(request, data["image_source"])
image_id = image.id
image_size = functions.bytes_to_gigabytes(image.size)
if (data['size'] < image_size):
error_message = _('The volume size cannot be less than '
'the image size (%s)' %
filesizeformat(image.size))
raise ValidationError(error_message)
else:
if type(data['size']) is str:
data['size'] = int(data['size'])
if availableGB < data['size']:
error_message = _('A volume of %(req)iGB cannot be created as '
'you only have %(avail)iGB of your quota '
'available.')
params = {'req': data['size'], 'avail': availableGB}
raise ValidationError(error_message % params)
elif availableVol <= 0:
error_message = _('You are already using all of your available'
' volumes.')
raise ValidationError(error_message)
metadata = {}
volume = cinder.volume_create(request,
data['size'],
data['name'],
data['description'],
data['type'],
snapshot_id=snapshot_id,
image_id=image_id,
metadata=metadata)
message = _('Creating volume "%s"') % data['name']
messages.info(request, message)
return volume
except ValidationError as e:
self.api_error(e.messages[0])
return False
except Exception:
exceptions.handle(request, ignore=True)
self.api_error(_("Unable to create volume."))
return False
def handle(self, request, data):
try:
usages = quotas.tenant_limit_usages(self.request)
availableGB = usages['maxTotalVolumeGigabytes'] - \
usages['gigabytesUsed']
availableVol = usages['maxTotalVolumes'] - usages['volumesUsed']
snapshot_id = None
image_id = None
volume_id = None
source_type = data.get('volume_source_type', None)
az = data.get('availability_zone', None) or None
if (data.get("snapshot_source", None)
and source_type in ['', None, 'snapshot_source']):
# Create from Snapshot
snapshot = self.get_snapshot(request, data["snapshot_source"])
snapshot_id = snapshot.id
if (data['size'] < snapshot.size):
error_message = (_('The volume size cannot be less than '
'the snapshot size (%sGiB)') %
snapshot.size)
raise ValidationError(error_message)
az = None
elif (data.get("image_source", None)
and source_type in ['', None, 'image_source']):
# Create from Snapshot
image = self.get_image(request, data["image_source"])
image_id = image.id
image_size = functions.bytes_to_gigabytes(image.size)
if (data['size'] < image_size):
error_message = (_('The volume size cannot be less than '
'the image size (%s)') %
filesizeformat(image.size))
raise ValidationError(error_message)
properties = getattr(image, 'properties', {})
min_disk_size = (getattr(image, 'min_disk', 0)
or properties.get('min_disk', 0))
if (min_disk_size > 0 and data['size'] < min_disk_size):
error_message = (_('The volume size cannot be less than '
'the image minimum disk size (%sGiB)') %
min_disk_size)
raise ValidationError(error_message)
elif (data.get("volume_source", None)
and source_type in ['', None, 'volume_source']):
# Create from volume
volume = self.get_volume(request, data["volume_source"])
volume_id = volume.id
if data['size'] < volume.size:
error_message = (_('The volume size cannot be less than '
'the source volume size (%sGiB)') %
volume.size)
raise ValidationError(error_message)
else:
if type(data['size']) is str:
data['size'] = int(data['size'])
if availableGB < data['size']:
error_message = _('A volume of %(req)iGiB cannot be created '
'as you only have %(avail)iGiB of your '
'quota available.')
params = {'req': data['size'], 'avail': availableGB}
raise ValidationError(error_message % params)
elif availableVol <= 0:
error_message = _('You are already using all of your available'
' volumes.')
raise ValidationError(error_message)
metadata = {}
volume = cinder.volume_create(request,
data['size'],
data['name'],
data['description'],
data['type'],
snapshot_id=snapshot_id,
image_id=image_id,
metadata=metadata,
availability_zone=az,
source_volid=volume_id)
message = _('Creating volume "%s"') % data['name']
messages.info(request, message)
return volume
except ValidationError as e:
self.api_error(e.messages[0])
return False
except Exception:
redirect = reverse("horizon:admin:volumes:index")
exceptions.handle(request,
_("Unable to create volume."),
redirect=redirect)
def test_create_volume_from_volume(self):
volume = self.volumes.first()
usage_limit = {
'maxTotalVolumeGigabytes': 250,
'gigabytesUsed': 20,
'volumesUsed': len(self.volumes.list()),
'maxTotalVolumes': 6
}
formData = {
'name': u'A copy of a volume',
'description': u'This is a volume I am making for a test.',
'method': u'CreateForm',
'size': 50,
'type': '',
'volume_source_type': 'volume_source',
'volume_source': volume.id
}
cinder.volume_list(IsA(http.HttpRequest)).\
AndReturn(self.volumes.list())
cinder.volume_type_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_types.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).\
AndReturn(self.volume_snapshots.list())
quotas.tenant_limit_usages(IsA(http.HttpRequest)).\
AndReturn(usage_limit)
cinder.volume_get(IsA(http.HttpRequest),
volume.id).AndReturn(self.volumes.first())
cinder.extension_supported(IsA(http.HttpRequest),
'AvailabilityZones').AndReturn(True)
cinder.availability_zone_list(IsA(http.HttpRequest)).AndReturn(
self.cinder_availability_zones.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
cinder.volume_create(IsA(http.HttpRequest),
formData['size'],
formData['name'],
formData['description'],
'',
metadata={},
snapshot_id=None,
image_id=None,
availability_zone=None,
source_volid=volume.id).AndReturn(volume)
self.mox.ReplayAll()
url = reverse('horizon:project:volumes:volumes:create')
redirect_url = reverse('horizon:project:volumes:index')
res = self.client.post(url, formData)
self.assertNoFormErrors(res)
self.assertMessageCount(info=1)
self.assertRedirectsNoFollow(res, redirect_url)
