def test_update_port_name(self):
nic = dbmf.NetworkInterfaceFactory(device_owner='vm')
url = join_urls(PORTS_URL, str(nic.id))
request = {'port': {"name": u"test-name\u2601\u2602"}}
response = self.put(url, params=json.dumps(request), user=nic.userid)
self.assertEqual(response.status_code, 200)
res = json.loads(response.content)
self.assertEqual(res['port']['name'], u"test-name\u2601\u2602")
def test_remove(self, client):
vm = mfactory.VirtualMachineFactory(flavor__cpu=1, flavor__ram=128)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=1)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=3)
# Also create a NIC
ip = mfactory.IPv4AddressFactory(nic__machine=vm)
nic = ip.nic
with transaction.atomic():
nic.network.get_ip_pools()[0].reserve(nic.ipv4_address)
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm.backend_vm_id)
with mocked_quotaholder() as m:
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
# Check that nics are deleted
self.assertFalse(db_vm.nics.all())
with transaction.atomic():
self.assertTrue(nic.network.get_ip_pools()[0].is_available(ip.address))
# Check that volumes are deleted
self.assertFalse(db_vm.volumes.filter(deleted=False))
# Check quotas
name, args, kwargs = m.mock_calls[0]
for (userid, res), value in args[1].items():
if res == 'cyclades.disk':
self.assertEqual(value, -4 << 30)
elif res == 'cyclades.cpu':
self.assertEqual(value, -1)
elif res == 'cyclades.ram':
self.assertEqual(value, -128 << 20)
vm2 = mfactory.VirtualMachineFactory()
fp1 = mfactory.IPv4AddressFactory(nic__machine=vm2, floating_ip=True,
network__floating_ip_pool=True)
network = fp1.network
nic1 = mfactory.NetworkInterfaceFactory(machine=vm2)
fp1.nic = nic1
fp1.save()
with transaction.atomic():
pool = network.get_ip_pools()[0]
pool.reserve(fp1.address)
pool.save()
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm2.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
self.assertEqual(2, client.basic_ack.call_count)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
self.assertEqual(IPAddress.objects.get(id=fp1.id).nic, None)
with transaction.atomic():
pool = network.get_ip_pools()[0]
# Test that floating ips are not released
self.assertFalse(pool.is_available(fp1.address))
def test_delete_port(self, mrapi):
nic = dbmf.NetworkInterfaceFactory(device_owner='vm')
url = join_urls(PORTS_URL, str(nic.id))
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.delete(url, user=nic.userid)
self.assertEqual(response.status_code, 204)
with override_settings(settings, GANETI_USE_HOTPLUG=False):
response = self.delete(url, user=nic.userid)
self.assertEqual(response.status_code, 400)
def setUp(self):
settings.SKIP_SSH_VALIDATION = True
settings.HELPDESK_ENABLED = True
self.client = AuthClient()
# init models
vm1u1 = mfactory.VirtualMachineFactory(userid=USER1, name="user1 vm",
pk=1001)
vm1u2 = mfactory.VirtualMachineFactory(userid=USER2, name="user2 vm1",
pk=1002)
vm2u2 = mfactory.VirtualMachineFactory(userid=USER2, name="user2 vm2",
pk=1003)
netpub = mfactory.NetworkFactory(public=True)
net1u1 = mfactory.NetworkFactory(public=False, userid=USER1)
nic1 = mfactory.NetworkInterfaceFactory(machine=vm1u2, network=net1u1)
nic2 = mfactory.NetworkInterfaceFactory(machine=vm1u1, network=netpub,
ipv4="195.251.222.211")
def test_get_network_building_nics(self, mrapi):
net = mfactory.NetworkFactory()
machine = mfactory.VirtualMachineFactory(userid=net.userid)
mfactory.NetworkInterfaceFactory(network=net,
machine=machine,
state="BUILDING")
response = self.myget('networks/%d' % net.id, net.userid)
self.assertSuccess(response)
api_net = json.loads(response.content)["network"]
self.assertEqual(len(api_net["attachments"]), 0)
def setUp(self):
settings.SKIP_SSH_VALIDATION = True
settings.HELPDESK_ENABLED = True
self.client = AuthClient()
# init models
vm1u1 = mfactory.VirtualMachineFactory(userid=USER1,
name="user1 vm",
pk=1001)
vm1u2 = mfactory.VirtualMachineFactory(userid=USER2,
name="user2 vm1",
pk=1002)
vm2u2 = mfactory.VirtualMachineFactory(userid=USER2,
name="user2 vm2",
pk=1003)
nic1 = mfactory.NetworkInterfaceFactory(machine=vm1u2,
userid=vm1u2.userid,
network__public=False,
network__userid=USER1)
nic2 = mfactory.NetworkInterfaceFactory(machine=vm1u2,
userid=vm1u2.userid,
network__public=False,
network__userid=USER1)
ip2 = mfactory.IPv4AddressFactory(nic__machine=vm1u1,
userid=vm1u1.userid,
network__public=True,
network__userid=None,
address="195.251.222.211")
ipv6 = mfactory.IPv4AddressFactory(nic__machine=vm1u1,
userid=vm1u1.userid,
network__public=True,
network__userid=None,
address="2001:648:2ffc:200::184")
mfactory.IPAddressLogFactory(address=ip2.address,
server_id=vm1u1.id,
network_id=ip2.network.id,
active=True)
mfactory.IPAddressLogFactory(address=ipv6.address,
server_id=vm1u1.id,
network_id=ipv6.network.id,
active=True)
def test_server_building_nics(self):
db_vm = self.vm2
user = self.vm2.userid
net1 = mfactory.NetworkFactory()
net2 = mfactory.NetworkFactory()
net3 = mfactory.NetworkFactory()
mfactory.NetworkInterfaceFactory(machine=self.vm2,
network=net1,
state="BUILD")
nic2 = mfactory.NetworkInterfaceFactory(machine=self.vm2,
network=net2,
state="ACTIVE")
mfactory.NetworkInterfaceFactory(machine=self.vm2,
network=net3,
state="BUILD")
response = self.myget('servers/%d' % db_vm.id, user)
server = json.loads(response.content)['server']
nics = server["attachments"]
self.assertEqual(len(nics), 1)
self.assertEqual(nics[0]["network_id"], str(nic2.network_id))
def test_remove_nic_malformed(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user)
nic = mfactory.NetworkInterfaceFactory(machine=vm, network=net)
request = {
'remove': {
'att234achment': 'nic-%s-%s' % (vm.id, nic.index)
}
}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertBadRequest(response)
def test_remove(self, client):
vm = mfactory.VirtualMachineFactory()
# Also create a NIC
mfactory.NetworkInterfaceFactory(machine=vm)
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
client.basic_ack.assert_called_once()
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
# Check that nics are deleted
self.assertFalse(db_vm.nics.all())
def test_remove_nic(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user)
nic = mfactory.NetworkInterfaceFactory(machine=vm, network=net)
request = {'remove': {'attachment': 'nic-%s-%s' % (vm.id, nic.index)}}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
self.assertTrue(NetworkInterface.objects.get(id=nic.id).dirty)
# Remove dirty nic
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertFault(response, 409, 'buildInProgress')
def test_delete(self):
"""Test if the delete action succeeds/fails properly."""
# Create a floating IP and force-attach it to a NIC instance.
vm = mfactory.VirtualMachineFactory()
nic = mfactory.NetworkInterfaceFactory(network=self.network,
machine=vm)
with mocked_quotaholder():
ip = ips.create_floating_ip(self.credentials,
network_id=self.network.id)
ip.nic = nic
ip.save()
# Test 1 - Check if we can delete an IP attached to a VM.
#
# The validate function and the action should both fail with the
# following message.
expected_msg = "IP '{}' is used by server '{}'".format(ip.id, vm.id)
# Verify that the validate function fails in silent mode.
res, msg = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertFalse(res)
self.assertEqual(msg, expected_msg)
# Verify that the validate function fails in non-silent mode.
with self.assertRaises(faults.Conflict) as cm:
ips.validate_ip_action(ip, "DELETE", silent=False)
self.assertEqual(cm.exception.message, expected_msg)
# Verify that the delete action fails with exception.
with mocked_quotaholder():
with self.assertRaises(faults.Conflict) as cm:
ips.delete_floating_ip(ip.id, self.credentials)
self.assertEqual(cm.exception.message, expected_msg)
# Test 2 - Check if we can delete a free IP.
#
# Force-detach IP from NIC.
ip.nic = None
ip.save()
# Verify that the validate function passes in silent mode.
res, _ = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertTrue(res)
# Verify that the delete action succeeds.
with mocked_quotaholder():
ips.delete_floating_ip(ip.id, self.credentials)
with self.assertRaises(ObjectDoesNotExist):
IPAddress.objects.get(id=ip.id)
def test_server_detail(self):
"""Test if a server details are returned."""
db_vm = self.vm2
user = self.vm2.userid
net = mfactory.NetworkFactory()
nic = mfactory.NetworkInterfaceFactory(machine=self.vm2,
network=net,
ipv6="::babe")
db_vm_meta = mfactory.VirtualMachineMetadataFactory(vm=db_vm)
response = self.myget('servers/%d' % db_vm.id, user)
server = json.loads(response.content)['server']
self.assertEqual(server['flavor']["id"], db_vm.flavor.id)
self.assertEqual(server['hostId'], db_vm.hostid)
self.assertEqual(server['id'], db_vm.id)
self.assertEqual(server['image']["id"], db_vm.imageid)
self.assertEqual(server['name'], db_vm.name)
self.assertEqual(server['status'], get_rsapi_state(db_vm))
api_nic = server['attachments'][0]
self.assertEqual(api_nic['network_id'], str(net.id))
self.assertEqual(api_nic['mac_address'], nic.mac)
self.assertEqual(api_nic['firewallProfile'], nic.firewall_profile)
self.assertEqual(api_nic['ipv4'], nic.ipv4)
self.assertEqual(api_nic['ipv6'], nic.ipv6)
self.assertEqual(api_nic['id'], 'nic-%s-%s' % (db_vm.id, nic.index))
api_address = server["addresses"]
self.assertEqual(api_address[str(net.id)], [{
"version": 4,
"addr": nic.ipv4,
"OS-EXT-IPS:type": "fixed"
}, {
"version": 6,
"addr": nic.ipv6,
"OS-EXT-IPS:type": "fixed"
}])
metadata = server['metadata']
self.assertEqual(len(metadata), 1)
self.assertEqual(metadata[db_vm_meta.meta_key], db_vm_meta.meta_value)
self.assertSuccess(response)
def test_remove(self, client):
vm = mfactory.VirtualMachineFactory()
# Also create a NIC
ip = mfactory.IPv4AddressFactory(nic__machine=vm)
nic = ip.nic
nic.network.get_ip_pools()[0].reserve(nic.ipv4_address)
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
# Check that nics are deleted
self.assertFalse(db_vm.nics.all())
self.assertTrue(nic.network.get_ip_pools()[0].is_available(ip.address))
vm2 = mfactory.VirtualMachineFactory()
fp1 = mfactory.IPv4AddressFactory(nic__machine=vm2,
floating_ip=True,
network__floating_ip_pool=True)
network = fp1.network
nic1 = mfactory.NetworkInterfaceFactory(machine=vm2)
fp1.nic = nic1
fp1.save()
pool = network.get_ip_pools()[0]
pool.reserve(fp1.address)
pool.save()
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm2.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
client.basic_ack.assert_called_once()
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
self.assertEqual(IPAddress.objects.get(id=fp1.id).nic, None)
pool = network.get_ip_pools()[0]
# Test that floating ips are not released
self.assertFalse(pool.is_available(fp1.address))
def test_firewall(self, mrapi, mimage):
vm = mfactory.VirtualMachineFactory()
vm.operstate = "STOPPED"
vm.save()
request = {'firewallProfile': {'profile': 'PROTECTED'}}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertBadRequest(response)
request = {'firewallProfile': {'profile': 'PROTECTED', "nic": "10"}}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertItemNotFound(response)
request = {'firewallProfile': {'profile': 'PROTECTED', "nic": "error"}}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertBadRequest(response)
nic = mfactory.NetworkInterfaceFactory(machine=vm)
request = {'firewallProfile': {'profile': 'PROTECTED', "nic": nic.id}}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertSuccess(response)
mrapi().ModifyInstance.assert_called_once()
def test_get_port(self):
nic = dbmf.NetworkInterfaceFactory()
url = join_urls(PORTS_URL, str(nic.id))
response = self.get(url, user=nic.userid)
self.assertEqual(response.status_code, 200)
def test_delete_network_in_use(self):
test_net = dbmf.NetworkFactory()
dbmf.NetworkInterfaceFactory(network=test_net)
url = join_urls(NETWORKS_URL, str(test_net.id))
response = self.delete(url, user=test_net.userid)
self.assertEqual(response.status_code, 409)
