def validate_post_only_url(self, url, args=None, data=dict(), users=None,
get_allowed=False):
"""
Generic function for POSTing to URLs.
This function does some standard URL checks, then does two POSTs: One
normal, and one with a faked error. Additionally, if ``get_allowed``
is not set, the GET method is checked to make sure it fails.
"""
args = args if args else (self.cluster.slug, self.vm.hostname)
users = users if users else [self.superuser, self.vm_admin,
self.cluster_admin]
# Only do the standard assertions if GET is allowed. POST-only URLs
# generally don't give a shit about any GET requests and will 405 all
# of them.
if get_allowed:
self.assert_standard_fails(url, args)
else:
self.assertTrue(self.c.login(username=self.superuser.username,
password='******'))
response = self.c.get(url % args, data)
self.assertEqual(405, response.status_code)
def test_json(user, response):
content = json.loads(response.content)
self.assertEqual('1', content['id'])
VirtualMachine.objects.all().update(last_job=None)
Job.objects.all().delete()
def test_json_error(user, response):
content = json.loads(response.content)
self.assertTrue("__all__" in content)
self.assertTrue(len(content["__all__"]))
text = content['__all__'][0]
self.assertEqual(msg, text)
self.vm.rapi.error = None
self.assert_200(url, args, users, data=data, tests=test_json,
mime='application/json', method='post')
msg = "SIMULATING_AN_ERROR"
self.vm.rapi.error = client.GanetiApiError(msg)
self.assert_200(url, args, [self.superuser], data=data,
tests=test_json_error, mime='application/json',
method='post')
def test_refresh_error(self):
"""
Test an error during refresh
Verifies:
* error will be saved in object.error
* successful refresh after will clear error
"""
object = self.create_model()
msg = "SIMULATING AN ERROR"
# force an error to test its capture
object.throw_error = client.GanetiApiError(msg)
object.save()
object.refresh()
self.assertEqual(msg, object.error)
# clear the error and retry
object.throw_error = None
object.save()
self.test_refresh(object)
self.assertEqual(None, object.error)
def test_manager_methods(self):
"""
Test useful GanetiErrorManager methods:
* store_error
* get_errors
* clear_errors
* clear_error
* remove_errors
Verifies:
* all those methods are free of errors
"""
cluster0 = self.create_model(Cluster,
hostname="test0",
slug="OSL_TEST0")
cluster1 = self.create_model(Cluster,
hostname="test1",
slug="OSL_TEST1")
cluster2 = self.create_model(Cluster,
hostname="test2",
slug="OSL_TEST2")
vm0 = self.create_model(VirtualMachine,
cluster=cluster0,
hostname="vm0.test.org")
vm1 = self.create_model(VirtualMachine,
cluster=cluster1,
hostname="vm1.test.org")
msg = client.GanetiApiError("Simulating an error", 777)
RapiProxy.error = msg
# test store_error
store_error = GanetiError.store_error
store_error(str(msg), obj=cluster0, code=msg.code)
store_error(str(msg), obj=cluster1, code=msg.code)
store_error(str(msg), obj=cluster2, code=msg.code)
store_error(str(msg), obj=vm0, code=msg.code)
store_error(str(msg), obj=vm1, code=msg.code)
# test get_errors
get_errors = GanetiError.objects.get_errors
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 2)
errors = get_errors(obj=cluster1)
self.assertEqual(len(errors), 2)
errors = get_errors(obj=cluster2)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm1)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=Cluster.objects.all())
self.assertEqual(len(errors), 5)
errors = get_errors(obj=VirtualMachine.objects.all())
self.assertEqual(len(errors), 2)
# test clear_error(s)
clear_errors = GanetiError.objects.clear_errors
clear_errors(obj=cluster2)
errors = GanetiError.objects.filter(cleared=False)
self.assertEqual(len(errors), 4)
clear_errors(obj=vm1)
errors = GanetiError.objects.filter(cleared=False)
self.assertEqual(len(errors), 3)
GanetiError.objects.filter(msg=str(msg)).clear_errors()
errors = GanetiError.objects.filter(cleared=False)
self.assertEqual(len(errors), 0)
get_errors(obj=cluster2).delete()
errors = GanetiError.objects.all()
self.assertEqual(len(errors), 4)
get_errors(obj=vm1).delete()
errors = GanetiError.objects.all()
self.assertEqual(len(errors), 3)
GanetiError.objects.filter(msg=str(msg)).delete()
errors = GanetiError.objects.all()
self.assertEqual(len(errors), 0)
def test_clear_error(self):
url = '/error/clear/%s'
msg = client.GanetiApiError("Simulating an error", 777)
RapiProxy.error = msg
# test store_error
store_error = GanetiError.store_error
c_error = store_error(str(msg), obj=self.cluster, code=msg.code)
c_error = GanetiError.objects.get(pk=c_error.pk)
self.assertFalse(c_error.cleared)
vm_error = store_error(str(msg), obj=self.vm, code=msg.code)
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertFalse(vm_error.cleared)
# anonymous user
response = self.c.post(url % vm_error.id, follow=True)
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, 'registration/login.html')
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertFalse(vm_error.cleared)
# unauthorized user
self.assertTrue(
self.c.login(username=self.user.username, password='******'))
response = self.c.post(url % vm_error.id)
self.assertEqual(403, response.status_code)
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertFalse(vm_error.cleared)
# nonexisent error
response = self.c.post(url % -1)
self.assertEqual(404, response.status_code)
# authorized for cluster (cluster admin)
self.user.grant('admin', self.cluster)
response = self.c.post(url % c_error.id)
self.assertEqual(200, response.status_code)
c_error = GanetiError.objects.get(pk=c_error.pk)
self.assertTrue(c_error.cleared)
GanetiError.objects.all().update(cleared=False)
# authorized for vm (cluster admin)
response = self.c.post(url % vm_error.id)
self.assertEqual(200, response.status_code)
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertTrue(vm_error.cleared)
GanetiError.objects.all().update(cleared=False)
self.user.revoke_all(self.cluster)
# authorized for vm (vm owner)
self.vm.owner = self.user.get_profile()
self.vm.save()
response = self.c.post(url % vm_error.id)
self.assertEqual(200, response.status_code)
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertTrue(vm_error.cleared)
GanetiError.objects.all().update(cleared=False)
self.vm.owner = None
self.vm.save()
# authorized for vm (superuser)
self.user.is_superuser = True
self.user.save()
response = self.c.post(url % vm_error.id)
self.assertEqual(200, response.status_code)
vm_error = GanetiError.objects.get(pk=vm_error.pk)
self.assertTrue(vm_error.cleared)
GanetiError.objects.all().update(cleared=False)
def test_refresh_error(self):
"""
Test an error during refresh
Verifies:
* error will be saved as GanetiError object
* successful refresh after will clear error
"""
cluster0 = self.create_model(Cluster,
hostname="test0",
slug="OSL_TEST0")
cluster1 = self.create_model(Cluster,
hostname="test1",
slug="OSL_TEST1")
vm0 = self.create_model(VirtualMachine,
cluster=cluster0,
hostname="vm0.test.org")
vm1 = self.create_model(VirtualMachine,
cluster=cluster1,
hostname="vm1.test.org")
msg = client.GanetiApiError("Simulating an error", 777)
RapiProxy.error = msg
# force an error on all objects to test its capture
for i in (cluster0, cluster1, vm0, vm1):
i.refresh()
self.assertEqual(str(msg), i.error)
# get errors for object
# TODO: check log format
if isinstance(i, VirtualMachine):
errors = GanetiError.objects.get_errors(obj=i.cluster)
self.assertEqual(2, len(errors))
self.assertEqual(errors[0].cleared, False)
self.assertEqual(errors[1].cleared, False)
self.assertEqual(errors[0].msg, str(msg))
self.assertEqual(errors[1].msg, str(msg))
self.assertEqual(errors[0].code, msg.code)
self.assertEqual(errors[1].code, msg.code)
qs = GanetiError.objects.filter(cleared=True)
cleared = qs.get_errors(obj=i.cluster)
self.assertEqual(0, len(cleared))
else:
errors = GanetiError.objects.get_errors(obj=i)
self.assertEqual(1, len(errors))
self.assertEqual(errors[0].cleared, False)
self.assertEqual(errors[0].msg, str(msg))
self.assertEqual(errors[0].code, msg.code)
qs = GanetiError.objects.filter(cleared=True)
cleared = qs.get_errors(obj=i)
self.assertEqual(0, len(cleared))
# set all errors as cleared and test if it was a success
for i in (cluster0, cluster1):
GanetiError.objects.clear_errors(obj=i)
qs = GanetiError.objects.filter(cleared=True)
cleared = qs.get_errors(obj=i)
self.assertEqual(2, len(cleared))
self.assertEqual(cleared[0].cleared, True)
self.assertEqual(cleared[1].cleared, True)
self.assertEqual(cleared[0].msg, str(msg))
self.assertEqual(cleared[1].msg, str(msg))
self.assertEqual(cleared[0].code, msg.code)
self.assertEqual(cleared[1].code, msg.code)
for i in (vm0, vm1):
GanetiError.objects.clear_errors(obj=i.cluster)
qs = GanetiError.objects.filter(cleared=True)
cleared = qs.get_errors(obj=i.cluster)
self.assertEqual(2, len(cleared))
self.assertEqual(cleared[0].cleared, True)
self.assertEqual(cleared[1].cleared, True)
self.assertEqual(cleared[0].msg, str(msg))
self.assertEqual(cleared[1].msg, str(msg))
self.assertEqual(cleared[0].code, msg.code)
self.assertEqual(cleared[1].code, msg.code)
# clear the error and retry
RapiProxy.error = None
for i in (cluster0, cluster1, vm0, vm1):
self.refresh(i)
self.assertEqual(None, i.error)
def test_specified_code_values(self):
"""
Test if errors with code in (401, 404) are stored in a proper way.
See tickets #2877, #2883.
Verifies:
* Manager store_error works properly for specific code numbers
"""
cluster0 = self.create_model(Cluster,
hostname="test0",
slug="OSL_TEST0")
vm0 = self.create_model(VirtualMachine,
cluster=cluster0,
hostname="vm0.test.org")
msg0 = client.GanetiApiError("Simulating 401 error", 401)
msg1 = client.GanetiApiError("Simulating 404 error", 404)
RapiProxy.error = msg0
store_error = GanetiError.store_error
get_errors = GanetiError.objects.get_errors
# 401 - cluster
store_error(str(msg0), obj=cluster0, code=msg0.code)
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 0)
get_errors(obj=cluster0).delete()
# 401 - VM
store_error(str(msg0), obj=vm0, code=msg0.code)
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 0)
get_errors(obj=cluster0).delete()
get_errors(obj=vm0).delete()
# 404 - VM
store_error(str(msg1), obj=vm0, code=msg1.code)
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 1)
get_errors(obj=cluster0).delete()
get_errors(obj=vm0).delete()
# 404 - cluster
store_error(str(msg1), obj=cluster0, code=msg1.code)
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 0)
# 404 - VM, but error is really with cluster
store_error(str(msg1), obj=vm0, code=msg1.code)
errors = get_errors(obj=cluster0)
self.assertEqual(len(errors), 1)
errors = get_errors(obj=vm0)
self.assertEqual(len(errors), 0)
get_errors(obj=cluster0).delete()
def test_view_create_data(self):
url = '/vm/add/%s'
group1 = Group(id=81, name='testing_group2')
group1.save()
cluster1 = Cluster(hostname='test2.example.bak', slug='OSL_TEST2')
cluster1.save()
data = self.data
# Login and grant user.
self.assertTrue(
self.c.login(username=self.user.username, password='******'))
self.user.grant('create_vm', self.cluster)
self.cluster.set_quota(self.user.get_profile(),
dict(ram=1000, disk=2000, virtual_cpus=10))
# POST - user authorized for cluster (create_vm)
self.user.grant('create_vm', self.cluster)
data_ = data.copy()
self.assertFalse(
VirtualMachine.objects.filter(hostname='new.vm.hostname').exists())
response = self.c.post(url % '', data_, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.user.has_perm('admin', new_vm))
self.user.revoke_all(self.cluster)
self.user.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# POST - user authorized for cluster (admin)
self.user.grant('admin', self.cluster)
response = self.c.post(url % '', data, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.user.has_perm('admin', new_vm))
VirtualMachine.objects.all().delete()
self.user.revoke_all(self.cluster)
self.user.revoke_all(new_vm)
# POST - User attempting to be other user
self.user.grant('admin', self.cluster)
data_ = data.copy()
data_['owner'] = self.user1.get_profile().id
response = self.c.post(url % '', data_)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response, 'ganeti/virtual_machine/create.html')
self.assertFalse(
VirtualMachine.objects.filter(hostname='new.vm.hostname').exists())
self.user.revoke_all(self.cluster)
# POST - user authorized for cluster (superuser)
self.user.is_superuser = True
self.user.save()
response = self.c.post(url % '', data, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.user.has_perm('admin', new_vm))
self.user.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# POST - ganeti error
self.cluster.rapi.CreateInstance.error = client.GanetiApiError(
'Testing Error')
response = self.c.post(url % '', data)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response, 'ganeti/virtual_machine/create.html')
self.assertFalse(
VirtualMachine.objects.filter(hostname='new.vm.hostname').exists())
self.cluster.rapi.CreateInstance.error = None
# POST - User attempting to be other user (superuser)
data_ = data.copy()
data_['owner'] = self.user1.get_profile().id
response = self.c.post(url % '', data_, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.user1.has_perm('admin', new_vm))
self.assertEqual([], self.user.get_perms(new_vm))
self.user.revoke_all(new_vm)
self.user1.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# reset for group owner
self.user.is_superuser = False
self.user.save()
data['owner'] = self.group.organization.id
# POST - user is not member of group
self.user.grant('admin', self.cluster)
self.group.grant('create_vm', self.cluster)
self.assertFalse(self.group in self.user.groups.all())
response = self.c.post(url % '', data)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response, 'ganeti/virtual_machine/create.html')
self.assertFalse(
VirtualMachine.objects.filter(hostname='new.vm.hostname').exists())
self.user.revoke_all(self.cluster)
self.group.revoke_all(self.cluster)
VirtualMachine.objects.all().delete()
# add user to group
self.group.user_set.add(self.user)
# POST - group authorized for cluster (create_vm)
self.group.grant('create_vm', self.cluster)
response = self.c.post(url % '', data, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.group.has_perm('admin', new_vm))
self.group.revoke_all(self.cluster)
self.group.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# POST - group authorized for cluster (admin)
self.group.grant('admin', self.cluster)
response = self.c.post(url % '', data, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.group.has_perm('admin', new_vm))
self.group.revoke_all(self.cluster)
self.group.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# POST - group authorized for cluster (superuser)
self.user.is_superuser = True
self.user.save()
response = self.c.post(url % '', data, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(self.group.has_perm('admin', new_vm))
self.group.revoke_all(new_vm)
VirtualMachine.objects.all().delete()
# POST - not a group member (superuser)
data_ = data.copy()
data_['owner'] = group1.organization.id
response = self.c.post(url % '', data_, follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual('text/html; charset=utf-8', response['content-type'])
self.assertTemplateUsed(response,
'ganeti/virtual_machine/create_status.html')
new_vm = VirtualMachine.objects.get(hostname='new.vm.hostname')
self.assertEqual(new_vm, response.context['instance'])
self.assertTrue(group1.has_perm('admin', new_vm))
self.assertFalse(self.group.has_perm('admin', new_vm))