def test_attach_wait_for_sync(self, mrapi):
"""Test wait_for_sync when attaching volume to instance.
"""
volume = mfactory.VolumeFactory()
vm = volume.machine
# Test Started VM
vm.operstate = "STARTED"
vm.save()
mrapi().ModifyInstance.return_value = 1
for sync in [True, False]:
with override_settings(settings, GANETI_DISKS_WAIT_FOR_SYNC=sync):
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
self.assertEqual(kwargs['wait_for_sync'], sync)
# Test Stopped VM. We do not pass wait_for_sync.
vm.operstate = "STOPPED"
vm.save()
mrapi().ModifyInstance.return_value = 1
for sync in [True, False]:
with override_settings(settings, GANETI_DISKS_WAIT_FOR_SYNC=sync):
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
self.assertFalse('wait_for_sync' in kwargs)
def test_server_fqdn(self):
vm = mfactory.VirtualMachineFactory()
# Setting set to None
with override_settings(settings, CYCLADES_SERVERS_FQDN=None):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], None)
# Unformated setting
with override_settings(settings,
CYCLADES_SERVERS_FQDN="vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], "vm.example.org")
# Formatted settings
with override_settings(
settings, CYCLADES_SERVERS_FQDN="snf-%(id)s.vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"],
"snf-%d.vm.example.org" % vm.id)
with override_settings(
settings,
CYCLADES_SERVERS_FQDN="snf-%(id)s.vm-%(id)s.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"],
"snf-%d.vm-%d.example.org" % (vm.id, vm.id))
def test_hypervisor(self):
from synnefo.db.models import snf_settings
kvm_backend = mfact.BackendFactory(hypervisor="kvm")
xen_pvm_backend = mfact.BackendFactory(hypervisor="xen-pvm")
xen_hvm_backend = mfact.BackendFactory(hypervisor="xen-hvm")
with override_settings(snf_settings, GANETI_USE_HOTPLUG=True):
self.assertTrue(kvm_backend.use_hotplug())
self.assertFalse(xen_pvm_backend.use_hotplug())
self.assertFalse(xen_hvm_backend.use_hotplug())
with override_settings(snf_settings, GANETI_USE_HOTPLUG=False):
self.assertFalse(kvm_backend.use_hotplug())
self.assertFalse(xen_pvm_backend.use_hotplug())
self.assertFalse(xen_hvm_backend.use_hotplug())
kwargs = {"os": "snf-image+default",
"hvparams": {"kvm": {"foo1": "mpaz1"},
"xen-pvm": {"foo2": "mpaz2"},
"xen-hvm": {"foo3": "mpaz3"}}}
with override_settings(snf_settings,
GANETI_CREATEINSTANCE_KWARGS=kwargs):
self.assertEqual(kvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo1": "mpaz1"}})
self.assertEqual(xen_pvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo2": "mpaz2"}})
self.assertEqual(xen_hvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo3": "mpaz3"}})
with override_settings(snf_settings, GANETI_CREATEINSTANCE_KWARGS={}):
self.assertEqual(kvm_backend.get_create_params(), {"hvparams": {}})
def test_server_fqdn(self):
vm = mfactory.VirtualMachineFactory()
# Setting set to None
with override_settings(settings,
CYCLADES_SERVERS_FQDN=None):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], None)
# Unformated setting
with override_settings(settings,
CYCLADES_SERVERS_FQDN="vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], "vm.example.org")
# Formatted settings
with override_settings(settings, CYCLADES_SERVERS_FQDN=
"snf-%(id)s.vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"],
"snf-%d.vm.example.org" % vm.id)
with override_settings(settings,
CYCLADES_SERVERS_FQDN=
"snf-%(id)s.vm-%(id)s.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], "snf-%d.vm-%d.example.org" %
(vm.id, vm.id))
def test_hypervisor(self):
from synnefo.db.models import snf_settings
kvm_backend = mfact.BackendFactory(hypervisor="kvm")
xen_pvm_backend = mfact.BackendFactory(hypervisor="xen-pvm")
xen_hvm_backend = mfact.BackendFactory(hypervisor="xen-hvm")
with override_settings(snf_settings, GANETI_USE_HOTPLUG=True):
self.assertTrue(kvm_backend.use_hotplug())
self.assertFalse(xen_pvm_backend.use_hotplug())
self.assertFalse(xen_hvm_backend.use_hotplug())
with override_settings(snf_settings, GANETI_USE_HOTPLUG=False):
self.assertFalse(kvm_backend.use_hotplug())
self.assertFalse(xen_pvm_backend.use_hotplug())
self.assertFalse(xen_hvm_backend.use_hotplug())
kwargs = {"os": "snf-image+default",
"hvparams": {"kvm": {"foo1": "mpaz1"},
"xen-pvm": {"foo2": "mpaz2"},
"xen-hvm": {"foo3": "mpaz3"}}}
with override_settings(snf_settings,
GANETI_CREATEINSTANCE_KWARGS=kwargs):
self.assertEqual(kvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo1": "mpaz1"}})
self.assertEqual(xen_pvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo2": "mpaz2"}})
self.assertEqual(xen_hvm_backend.get_create_params(),
{"os": "snf-image+default",
"hvparams": {"foo3": "mpaz3"}})
with override_settings(snf_settings, GANETI_CREATEINSTANCE_KWARGS={}):
self.assertEqual(kvm_backend.get_create_params(), {"hvparams": {}})
def test_create_port_private_net(self, mrapi):
net = dbmf.NetworkFactory(public=False)
dbmf.IPv4SubnetFactory(network=net)
dbmf.IPv6SubnetFactory(network=net)
sg1 = dbmf.SecurityGroupFactory()
sg2 = dbmf.SecurityGroupFactory()
vm = dbmf.VirtualMachineFactory(userid=net.userid)
request = {
"port": {
"name": "port1",
"network_id": str(net.id),
"device_id": str(vm.id),
"security_groups": [str(sg1.id), str(sg2.id)]
}
}
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=False):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 400)
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 201)
def test_server_port_forwarding(self):
vm = mfactory.VirtualMachineFactory()
# test None if the server has no public IP
ports = {22: ("foo", 61000), 80: lambda ip, id, fqdn, user: ("bar", 61001)}
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)["server"]
self.assertEqual(server["SNF:port_forwarding"], {})
# Add with public IP
mfactory.IPv4AddressFactory(nic__machine=vm, network__public=True)
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)["server"]
self.assertEqual(
server["SNF:port_forwarding"],
{"22": {"host": "foo", "port": "61000"}, "80": {"host": "bar", "port": "61001"}},
)
def _port_from_ip(ip, base):
fields = ip.split(".", 4)
return base + 256 * int(fields[2]) + int(fields[3])
ports = {22: lambda ip, id, fqdn, user: ip and ("gate", _port_from_ip(ip, 10000)) or None}
vm = mfactory.VirtualMachineFactory()
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)["server"]
self.assertEqual(server["SNF:port_forwarding"], {})
mfactory.IPv4AddressFactory(nic__machine=vm, network__public=True, address="192.168.2.2")
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)["server"]
self.assertEqual(server["SNF:port_forwarding"], {"22": {"host": "gate", "port": "10514"}})
def test_attach_wait_for_sync(self, mrapi):
"""Test wait_for_sync when attaching volume to instance.
"""
volume = mfactory.VolumeFactory()
vm = volume.machine
# Test Started VM
vm.operstate = "STARTED"
vm.save()
mrapi().ModifyInstance.return_value = 1
for sync in [True, False]:
with override_settings(settings, GANETI_DISKS_WAIT_FOR_SYNC=sync):
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
self.assertEqual(kwargs['wait_for_sync'], sync)
# Test Stopped VM. We do not pass wait_for_sync.
vm.operstate = "STOPPED"
vm.save()
mrapi().ModifyInstance.return_value = 1
for sync in [True, False]:
with override_settings(settings, GANETI_DISKS_WAIT_FOR_SYNC=sync):
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
self.assertFalse('wait_for_sync' in kwargs)
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 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 test_server_port_forwarding(self):
vm = mfactory.VirtualMachineFactory()
# test None if the server has no public IP
ports = {
22: ("foo", 61000),
80: lambda ip, id, fqdn, user: ("bar", 61001)
}
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"], {})
# Add with public IP
mfactory.IPv4AddressFactory(nic__machine=vm, network__public=True)
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(
server["SNF:port_forwarding"], {
"22": {
"host": "foo",
"port": "61000"
},
"80": {
"host": "bar",
"port": "61001"
}
})
def _port_from_ip(ip, base):
fields = ip.split('.', 4)
return (base + 256 * int(fields[2]) + int(fields[3]))
ports = {
22:
lambda ip, id, fqdn, user: ip and
("gate", _port_from_ip(ip, 10000)) or None
}
vm = mfactory.VirtualMachineFactory()
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"], {})
mfactory.IPv4AddressFactory(nic__machine=vm,
network__public=True,
address="192.168.2.2")
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"],
{"22": {
"host": "gate",
"port": "10514"
}})
def test_create_network_settings(self, mrapi):
mrapi().CreateInstance.return_value = 12
# User requested private networks
# no public IPv4
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC_IPV4"]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 503)
# no public IPv4, IPv6 exists
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC"]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(vm.nics.get().ipv4_address, None)
# IPv4 exists
mfactory.IPv4SubnetFactory(network__public=True,
cidr="192.168.2.0/24",
pool__offset=2,
pool__size=1)
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(vm.nics.get().ipv4_address, "192.168.2.2")
# Fixed networks
net1 = mfactory.NetworkFactory(userid="test")
net2 = mfactory.NetworkFactory(userid="test")
net3 = mfactory.NetworkFactory(userid="test")
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS": [net1.id, [net2.id, net3.id],
(net3.id, net2.id)]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(len(vm.nics.all()), 3)
def test_create_network_settings(self, mrapi):
mrapi().CreateInstance.return_value = 12
# User requested private networks
# no public IPv4
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC_IPV4"]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 503)
# no public IPv4, IPv6 exists
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC"]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(vm.nics.get().ipv4_address, None)
# IPv4 exists
mfactory.IPv4SubnetFactory(network__public=True,
cidr="192.168.2.0/24",
pool__offset=2,
pool__size=1)
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(vm.nics.get().ipv4_address, "192.168.2.2")
# Fixed networks
net1 = mfactory.NetworkFactory(userid="test")
net2 = mfactory.NetworkFactory(userid="test")
net3 = mfactory.NetworkFactory(userid="test")
network_settings = {
"CYCLADES_DEFAULT_SERVER_NETWORKS": [],
"CYCLADES_FORCED_SERVER_NETWORKS":
[net1.id, [net2.id, net3.id], (net3.id, net2.id)]
}
with override_settings(settings, **network_settings):
response = self.mypost('servers', "test", json.dumps(self.request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
vm = VirtualMachine.objects.get(id=server_id)
self.assertEqual(len(vm.nics.all()), 3)
def test_default_view(self):
"""Test if the default_view() function works as expected."""
self.assertEqual(utils.default_view(), 'user')
with override_settings(settings, ADMIN_VIEWS_ORDER=[]):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=['1', '2']):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=['1', 'user', '3']):
reload_settings()
self.assertEqual(utils.default_view(), 'user')
reload_settings()
def test_default_view(self):
"""Test if the default_view() function works as expected."""
self.assertEqual(utils.default_view(), "user")
with override_settings(settings, ADMIN_VIEWS_ORDER=[]):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=["1", "2"]):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=["1", "user", "3"]):
reload_settings()
self.assertEqual(utils.default_view(), "user")
reload_settings()
def test_create_port_without_device(self):
net = dbmf.NetworkWithSubnetFactory(userid="test_user",
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=3,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
}
}
response = self.post(PORTS_URL,
params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
# And with address
request["port"]["fixed_ips"] = [{"ip_address": "192.168.2.2"}]
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
self.assertEqual(new_port["fixed_ips"][0]["ip_address"], "192.168.2.2")
def test_create_server_wrong_flavor(self, mrapi):
# Test with a flavor that does not exist
request = deepcopy(self.request)
request["server"]["flavorRef"] = 42
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(request), "json")
self.assertItemNotFound(response)
# Test with an flavor that is not allowed
flavor = mfactory.FlavorFactory(allow_create=False)
request["server"]["flavorRef"] = flavor.id
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(request), "json")
self.assertEqual(response.status_code, 403)
def test_invalid_operstate_for_action(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
self.assertRaises(faults.BadRequest, servers.stop, vm)
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
flavor = mfactory.FlavorFactory()
self.assertRaises(faults.BadRequest, servers.resize, vm, flavor)
# Check that connect/disconnect is allowed only in STOPPED vms
# if hotplug is disabled.
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
network = mfactory.NetworkFactory(state="ACTIVE")
with override_settings(settings, GANETI_USE_HOTPLUG=False):
self.assertRaises(faults.BadRequest, servers.connect, vm, network)
self.assertRaises(faults.BadRequest, servers.disconnect, vm,
network)
#test valid
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder():
servers.start(vm)
vm.task = None
vm.task_job_id = None
vm.save()
with mocked_quotaholder():
quotas.accept_resource_serial(vm)
mrapi().RebootInstance.return_value = 1
with mocked_quotaholder():
servers.reboot(vm, "HARD")
def test_default_view(self):
"""Test if the default_view() function works as expected."""
self.assertEqual(utils.default_view(), 'user')
with override_settings(settings, ADMIN_VIEWS_ORDER=[]):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=['1', '2']):
reload_settings()
self.assertEqual(utils.default_view(), None)
with override_settings(settings, ADMIN_VIEWS_ORDER=['1', 'user', '3']):
reload_settings()
self.assertEqual(utils.default_view(), 'user')
reload_settings()
def test_create_port_without_device(self):
net = dbmf.NetworkWithSubnetFactory(userid="test_user",
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=3,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
}
}
response = self.post(PORTS_URL, params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
# And with address
request["port"]["fixed_ips"] = [{"ip_address": "192.168.2.2"}]
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user="******")
self.assertEqual(response.status_code, 201)
new_port = json.loads(response.content)["port"]
self.assertEqual(new_port["device_id"], None)
self.assertEqual(new_port["fixed_ips"][0]["ip_address"], "192.168.2.2")
def test_invalid_operstate_for_action(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
self.assertRaises(faults.BadRequest, servers.stop, vm)
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
flavor = mfactory.FlavorFactory()
self.assertRaises(faults.BadRequest, servers.resize, vm, flavor)
# Check that connect/disconnect is allowed only in STOPPED vms
# if hotplug is disabled.
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
network = mfactory.NetworkFactory(state="ACTIVE")
with override_settings(settings, GANETI_USE_HOTPLUG=False):
self.assertRaises(faults.BadRequest, servers.connect, vm, network)
self.assertRaises(faults.BadRequest, servers.disconnect, vm, network)
# test valid
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder():
servers.start(vm)
vm.task = None
vm.task_job_id = None
vm.save()
with mocked_quotaholder():
quotas.accept_resource_serial(vm)
mrapi().RebootInstance.return_value = 1
with mocked_quotaholder():
servers.reboot(vm, "HARD")
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"userid": "test",
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image": {
"id": "foo",
"backend_id": "foo",
"format": "diskdump",
"checksum": "test_checksum",
"metadata": "{}",
},
"networks": [],
"metadata": {"foo": "bar"},
"personality": [],
}
# no backend!
mfactory.BackendFactory(offline=True)
self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
mfactory.IPv4SubnetFactory(network__public=True)
mfactory.IPv6SubnetFactory(network__public=True)
backend = mfactory.BackendFactory()
# error in nics
req = deepcopy(kwargs)
req["networks"] = [{"uuid": 42}]
self.assertRaises(faults.ItemNotFound, servers.create, **req)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
# error in enqueue. check the vm is deleted and resources released
mrapi().CreateInstance.side_effect = Exception("ganeti is down")
with mocked_quotaholder():
servers.create(**kwargs)
vm = models.VirtualMachine.objects.get()
self.assertFalse(vm.deleted)
self.assertEqual(vm.operstate, "ERROR")
for nic in vm.nics.all():
self.assertEqual(nic.state, "ERROR")
# test ext settings:
req = deepcopy(kwargs)
ext_flavor = mfactory.FlavorFactory(disk_template="ext_archipelago", disk=1)
req["flavor"] = ext_flavor
mrapi().CreateInstance.return_value = 42
backend.disk_templates = ["ext"]
backend.save()
osettings = {"GANETI_DISK_PROVIDER_KWARGS": {"archipelago": {"foo": "mpaz", "lala": "lolo"}}}
with mocked_quotaholder():
with override_settings(settings, **osettings):
vm = servers.create(**req)
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
self.assertEqual(
kwargs["disks"][0],
{"provider": "archipelago", "origin": "test_checksum", "foo": "mpaz", "lala": "lolo", "size": 1024},
)
def test_attach_volume_type_specs(self, mrapi):
"""Test volume type spces propagation when attaching a
volume to an instance
"""
vlmt = mfactory.VolumeTypeFactory(disk_template='ext_archipelago')
# Generate 4 specs. 2 prefixed with GNT_EXTP_VOLTYPESPEC_PREFIX
# and 2 with an other prefix that should be omitted
volume_type_specs = [
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='%sbar' %
GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='%sfoo' %
GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='other-prefx-baz'),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='another-prefix-biz'),
]
gnt_prefixed_specs = filter(
lambda s: s.key.startswith(GNT_EXTP_VOLTYPESPEC_PREFIX),
volume_type_specs)
volume = mfactory.VolumeFactory(volume_type=vlmt, size=1)
vm = volume.machine
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with override_settings(settings, **osettings):
mrapi().ModifyInstance.return_value = 1
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
disk_kwargs = {
"provider": "archipelago",
"name": vm.volumes.all()[0].backend_volume_uuid,
"reuse_data": 'False',
"foo": "mpaz",
"lala": "lolo",
"size": 1024
}
disk_kwargs.update({
spec.key[len(GNT_EXTP_VOLTYPESPEC_PREFIX):]: spec.value
for spec in gnt_prefixed_specs
})
# Should be "disks": [('add', '-1', {disk_kwargs}), ]
disk = kwargs["disks"][0]
self.assertEqual(disk[0], 'add')
self.assertEqual(disk[1], '-1')
self.assertEqual(disk[2], disk_kwargs)
def test_create_server_wrong_flavor(self, mrapi):
# Test with a flavor that does not exist
request = deepcopy(self.request)
request["server"]["flavorRef"] = 42
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(request), 'json')
self.assertItemNotFound(response)
# Test with an flavor that is not allowed
flavor = mfactory.FlavorFactory(allow_create=False)
request["server"]["flavorRef"] = flavor.id
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(request), 'json')
self.assertEqual(response.status_code, 403)
def test_connect_network(self, mrapi):
# Common connect
for dhcp in [True, False]:
subnet = mfactory.IPv4SubnetFactory(network__flavor="CUSTOM",
cidr="192.168.2.0/24",
gateway="192.168.2.1",
dhcp=dhcp)
net = subnet.network
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
mfactory.BackendNetworkFactory(network=net, backend=vm.backend)
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=True):
with transaction.atomic():
port = servers._create_port(vm.userid, net)
servers.connect_port(vm, net, port)
pool = net.get_ip_pools(locked=False)[0]
self.assertFalse(pool.is_available("192.168.2.2"))
args, kwargs = mrapi().ModifyInstance.call_args
nics = kwargs["nics"][0]
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(nics[0], "add")
self.assertEqual(nics[1], "-1")
self.assertEqual(nics[2]["ip"], "192.168.2.2")
self.assertEqual(nics[2]["network"], net.backend_id)
# Test connect to IPv6 only network
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
subnet = mfactory.IPv6SubnetFactory(cidr="2000::/64",
gateway="2000::1")
net = subnet.network
mfactory.BackendNetworkFactory(network=net, backend=vm.backend)
with override_settings(settings, GANETI_USE_HOTPLUG=True):
with transaction.atomic():
port = servers._create_port(vm.userid, net)
servers.connect_port(vm, net, port)
args, kwargs = mrapi().ModifyInstance.call_args
nics = kwargs["nics"][0]
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(nics[0], "add")
self.assertEqual(nics[1], "-1")
self.assertEqual(nics[2]["ip"], None)
self.assertEqual(nics[2]["network"], net.backend_id)
def test_connect_network(self, mrapi):
# Common connect
for dhcp in [True, False]:
subnet = mfactory.IPv4SubnetFactory(network__flavor="CUSTOM",
cidr="192.168.2.0/24",
gateway="192.168.2.1",
dhcp=dhcp)
net = subnet.network
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
mfactory.BackendNetworkFactory(network=net, backend=vm.backend)
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=True):
with transaction.atomic():
port = servers._create_port(vm.userid, net)
servers.connect_port(vm, net, port)
pool = net.get_ip_pools(locked=False)[0]
self.assertFalse(pool.is_available("192.168.2.2"))
args, kwargs = mrapi().ModifyInstance.call_args
nics = kwargs["nics"][0]
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(nics[0], "add")
self.assertEqual(nics[1], "-1")
self.assertEqual(nics[2]["ip"], "192.168.2.2")
self.assertEqual(nics[2]["network"], net.backend_id)
# Test connect to IPv6 only network
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
subnet = mfactory.IPv6SubnetFactory(cidr="2000::/64",
gateway="2000::1")
net = subnet.network
mfactory.BackendNetworkFactory(network=net, backend=vm.backend)
with override_settings(settings, GANETI_USE_HOTPLUG=True):
with transaction.atomic():
port = servers._create_port(vm.userid, net)
servers.connect_port(vm, net, port)
args, kwargs = mrapi().ModifyInstance.call_args
nics = kwargs["nics"][0]
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(nics[0], "add")
self.assertEqual(nics[1], "-1")
self.assertEqual(nics[2]["ip"], None)
self.assertEqual(nics[2]["network"], net.backend_id)
def test_create_port_with_address(self, mrapi):
"""Test creation if IP address is specified."""
mrapi().ModifyInstance.return_value = 42
vm = dbmf.VirtualMachineFactory()
net = dbmf.NetworkWithSubnetFactory(userid=vm.userid,
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=1,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
"device_id": str(vm.id),
"fixed_ips": [{
"ip_address": "192.168.2.1"
}]
}
}
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertEqual(response.status_code, 201)
new_port_ip = json.loads(response.content)["port"]["fixed_ips"][0]
self.assertEqual(new_port_ip["ip_address"], "192.168.2.1")
# But 409 if address is already used
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertConflict(response)
# And bad request if IPv6 address is specified
request["port"]["fixed_ips"][0]["ip_address"] = "babe::"
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=vm.userid)
self.assertBadRequest(response)
def test_create_server_with_port(self, mrapi):
# Test invalid networks
request = deepcopy(self.request)
request["server"]["networks"] = {"foo": "lala"}
with override_settings(settings, **self.network_settings):
response = self.mypost("servers", "dummy_user",
json.dumps(request), 'json')
self.assertBadRequest(response)
request["server"]["networks"] = ['1', '2']
with override_settings(settings, **self.network_settings):
response = self.mypost("servers", "dummy_user",
json.dumps(request), 'json')
self.assertBadRequest(response)
mrapi().CreateInstance.return_value = 42
ip = mfactory.IPv4AddressFactory(nic__machine=None)
port1 = ip.nic
request = deepcopy(self.request)
request["server"]["networks"] = [{"port": port1.id}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", port1.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
vm_id = json.loads(response.content)["server"]["id"]
port1 = NetworkInterface.objects.get(id=port1.id)
self.assertEqual(port1.machine_id, vm_id)
# 409 if already used
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", port1.userid,
json.dumps(request), 'json')
self.assertConflict(response)
# Test permissions
ip = mfactory.IPv4AddressFactory(userid="user1", nic__userid="user1")
port2 = ip.nic
request["server"]["networks"] = [{"port": port2.id}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "user2", json.dumps(request),
'json')
self.assertEqual(response.status_code, 404)
def test_create_server_with_port(self, mrapi):
# Test invalid networks
request = deepcopy(self.request)
request["server"]["networks"] = {"foo": "lala"}
with override_settings(settings, **self.network_settings):
response = self.mypost("servers", "dummy_user",
json.dumps(request), 'json')
self.assertBadRequest(response)
request["server"]["networks"] = ['1', '2']
with override_settings(settings, **self.network_settings):
response = self.mypost("servers", "dummy_user",
json.dumps(request), 'json')
self.assertBadRequest(response)
mrapi().CreateInstance.return_value = 42
ip = mfactory.IPv4AddressFactory(nic__machine=None)
port1 = ip.nic
request = deepcopy(self.request)
request["server"]["networks"] = [{"port": port1.id}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", port1.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
vm_id = json.loads(response.content)["server"]["id"]
port1 = NetworkInterface.objects.get(id=port1.id)
self.assertEqual(port1.machine_id, vm_id)
# 409 if already used
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", port1.userid,
json.dumps(request), 'json')
self.assertConflict(response)
# Test permissions
ip = mfactory.IPv4AddressFactory(userid="user1", nic__userid="user1")
port2 = ip.nic
request["server"]["networks"] = [{"port": port2.id}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "user2",
json.dumps(request), 'json')
self.assertEqual(response.status_code, 404)
def test_attach_volume_type_specs(self, mrapi):
"""Test volume type spces propagation when attaching a
volume to an instance
"""
vlmt = mfactory.VolumeTypeFactory(disk_template='ext_archipelago')
# Generate 4 specs. 2 prefixed with GNT_EXTP_VOLTYPESPEC_PREFIX
# and 2 with an other prefix that should be omitted
volume_type_specs = [
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='%sbar' % GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='%sfoo' % GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='other-prefx-baz'),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='another-prefix-biz'),
]
gnt_prefixed_specs = filter(lambda s: s.key.startswith(
GNT_EXTP_VOLTYPESPEC_PREFIX), volume_type_specs)
volume = mfactory.VolumeFactory(volume_type=vlmt, size=1)
vm = volume.machine
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with override_settings(settings, **osettings):
mrapi().ModifyInstance.return_value = 1
jobid = backend.attach_volume(vm, volume)
self.assertEqual(jobid, 1)
name, args, kwargs = mrapi().ModifyInstance.mock_calls[-1]
disk_kwargs = {"provider": "archipelago",
"name": vm.volumes.all()[0].backend_volume_uuid,
"reuse_data": 'False',
"foo": "mpaz",
"lala": "lolo",
"size": 1024}
disk_kwargs.update({spec.key[len(GNT_EXTP_VOLTYPESPEC_PREFIX):]:
spec.value
for spec in gnt_prefixed_specs})
# Should be "disks": [('add', '-1', {disk_kwargs}), ]
disk = kwargs["disks"][0]
self.assertEqual(disk[0], 'add')
self.assertEqual(disk[1], '-1')
self.assertEqual(disk[2], disk_kwargs)
def test_invalid_create(self):
"""Test invalid flavor"""
request = {"network": {}}
response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
self.assertBadRequest(response)
request = {"network": {"type": "foo"}}
response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
self.assertBadRequest(response)
request = {"network": {"type": "MAC_FILTERED"}}
with override_settings(settings, API_ENABLED_NETWORK_FLAVORS=["CUSTOM"]):
response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
self.assertEqual(response.status_code, 403)
self.assertEqual(len(Network.objects.filter(userid="user1")), 0)
def test_create_port_with_address(self, mrapi):
"""Test creation if IP address is specified."""
mrapi().ModifyInstance.return_value = 42
vm = dbmf.VirtualMachineFactory()
net = dbmf.NetworkWithSubnetFactory(userid=vm.userid,
public=False,
subnet__cidr="192.168.2.0/24",
subnet__gateway=None,
subnet__pool__size=1,
subnet__pool__offset=1)
request = {
"port": {
"name": "port_with_address",
"network_id": str(net.id),
"device_id": str(vm.id),
"fixed_ips": [{"ip_address": "192.168.2.1"}]
}
}
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user=vm.userid)
self.assertEqual(response.status_code, 201)
new_port_ip = json.loads(response.content)["port"]["fixed_ips"][0]
self.assertEqual(new_port_ip["ip_address"], "192.168.2.1")
# But 409 if address is already used
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user=vm.userid)
self.assertConflict(response)
# And bad request if IPv6 address is specified
request["port"]["fixed_ips"][0]["ip_address"] = "babe::"
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user=vm.userid)
self.assertBadRequest(response)
def test_invalid_create(self):
"""Test invalid flavor"""
request = {'network': {}}
response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
self.assertBadRequest(response)
request = {'network': {"type": "foo"}}
response = self.post(NETWORKS_URL, "user1", params=json.dumps(request))
self.assertBadRequest(response)
request = {'network': {"type": "MAC_FILTERED"}}
with override_settings(settings,
API_ENABLED_NETWORK_FLAVORS=["CUSTOM"]):
response = self.post(NETWORKS_URL, "user1",
params=json.dumps(request))
self.assertEqual(response.status_code, 403)
self.assertEqual(len(Network.objects.filter(userid='user1')), 0)
def test_active_server(self):
"""Test console req for ACTIVE server"""
vm = mfactory.VirtualMachineFactory()
vm.operstate = "STARTED"
vm.save()
data = json.dumps({"console": {"type": "vnc"}})
with override_settings(settings, TEST=True):
response = self.mypost("servers/%d/action" % vm.id, vm.userid, data, "json")
self.assertEqual(response.status_code, 200)
reply = json.loads(response.content)
self.assertEqual(reply.keys(), ["console"])
console = reply["console"]
self.assertEqual(console["type"], "vnc")
self.assertEqual(set(console.keys()), set(["type", "host", "port", "password"]))
def test_create_port_private_net(self, mrapi):
net = dbmf.NetworkFactory(public=False)
dbmf.IPv4SubnetFactory(network=net)
dbmf.IPv6SubnetFactory(network=net)
sg1 = dbmf.SecurityGroupFactory()
sg2 = dbmf.SecurityGroupFactory()
vm = dbmf.VirtualMachineFactory(userid=net.userid)
request = {
"port": {
"name": "port1",
"network_id": str(net.id),
"device_id": str(vm.id),
"security_groups": [str(sg1.id), str(sg2.id)]
}
}
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=False):
response = self.post(PORTS_URL, params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 400)
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 201)
def test_create_server_error(self, mrapi):
"""Test if the create server call returns the expected response
if a valid request has been speficied."""
mrapi().CreateInstance.side_effect = GanetiApiError("..ganeti is down")
request = self.request
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(request), "json")
self.assertEqual(response.status_code, 202)
mrapi().CreateInstance.assert_called_once()
vm = VirtualMachine.objects.get()
# The VM has not been deleted
self.assertFalse(vm.deleted)
# but is in "ERROR" operstate
self.assertEqual(vm.operstate, "ERROR")
def test_create_server_error(self, mrapi):
"""Test if the create server call returns the expected response
if a valid request has been speficied."""
mrapi().CreateInstance.side_effect = GanetiApiError("..ganeti is down")
request = self.request
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
mrapi().CreateInstance.assert_called_once()
vm = VirtualMachine.objects.get()
# The VM has not been deleted
self.assertFalse(vm.deleted)
# but is in "ERROR" operstate
self.assertEqual(vm.operstate, "ERROR")
def test_active_server(self):
"""Test console req for ACTIVE server"""
vm = mfactory.VirtualMachineFactory()
vm.operstate = 'STARTED'
vm.save()
data = json.dumps({'console': {'type': 'vnc'}})
with override_settings(settings, TEST=True):
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
data, 'json')
self.assertEqual(response.status_code, 200)
reply = json.loads(response.content)
self.assertEqual(reply.keys(), ['console'])
console = reply['console']
self.assertEqual(console['type'], 'vnc')
self.assertEqual(set(console.keys()),
set(['type', 'host', 'port', 'password']))
def test_create_port_with_floating_ip(self, mrapi):
vm = dbmf.VirtualMachineFactory()
fip = dbmf.FloatingIPFactory(network__public=True, nic=None,
userid=vm.userid)
request = {
"port": {
"name": "Port in the \u2601",
"network_id": str(fip.network_id),
"device_id": str(vm.id),
"fixed_ips": [{"ip_address": fip.address}]
}
}
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL, params=json.dumps(request),
user=vm.userid)
self.assertEqual(response.status_code, 201)
def test_create_server(self, mrapi):
"""Test if the create server call returns the expected response
if a valid request has been speficied."""
mrapi().CreateInstance.return_value = 12
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(self.request), "json")
self.assertEqual(response.status_code, 202)
mrapi().CreateInstance.assert_called_once()
api_server = json.loads(response.content)["server"]
self.assertEqual(api_server["status"], "BUILD")
self.assertEqual(api_server["progress"], 0)
self.assertEqual(api_server["metadata"][u"Meta \u2601"], u"Meta in the \u2601")
self.assertTrue("adminPass" in api_server)
db_vm = VirtualMachine.objects.get(userid="test_user")
self.assertEqual(api_server["name"], u"Server in the \u2601")
self.assertEqual(api_server["status"], db_vm.operstate)
def test_create_server(self, mrapi):
"""Test if the create server call returns the expected response
if a valid request has been speficied."""
mrapi().CreateInstance.return_value = 12
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(self.request), 'json')
self.assertEqual(response.status_code, 202)
mrapi().CreateInstance.assert_called_once()
api_server = json.loads(response.content)['server']
self.assertEqual(api_server['status'], "BUILD")
self.assertEqual(api_server['progress'], 0)
self.assertEqual(api_server['metadata'][u"Meta \u2601"],
u"Meta in the \u2601")
self.assertTrue('adminPass' in api_server)
db_vm = VirtualMachine.objects.get(userid='test_user')
self.assertEqual(api_server['name'], u"Server in the \u2601")
self.assertEqual(api_server['status'], db_vm.operstate)
def test_create_server(self, mrapi):
"""Test if the create server call returns the expected response
if a valid request has been speficied."""
mrapi().CreateInstance.return_value = 12
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(self.request), 'json')
self.assertEqual(response.status_code, 202)
self.assertEqual(1, mrapi().CreateInstance.call_count)
api_server = json.loads(response.content)['server']
self.assertEqual(api_server['status'], "BUILD")
self.assertEqual(api_server['progress'], 0)
self.assertEqual(api_server['metadata'][u"Meta \u2601"],
u"Meta in the \u2601")
self.assertTrue('adminPass' in api_server)
db_vm = VirtualMachine.objects.get(userid='test_user')
self.assertEqual(api_server['name'], u"Server in the \u2601")
self.assertEqual(api_server['status'], db_vm.operstate)
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"userid": "test",
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image_id": "safs",
"networks": [],
"metadata": {
"foo": "bar"
},
"personality": [],
}
# no backend!
mfactory.BackendFactory(offline=True)
self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
mfactory.IPv4SubnetFactory(network__public=True)
mfactory.IPv6SubnetFactory(network__public=True)
backend = mfactory.BackendFactory()
# error in nics
req = deepcopy(kwargs)
req["networks"] = [{"uuid": 42}]
self.assertRaises(faults.ItemNotFound, servers.create, **req)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
# error in enqueue. check the vm is deleted and resources released
mrapi().CreateInstance.side_effect = Exception("ganeti is down")
with mocked_quotaholder():
servers.create(**kwargs)
vm = models.VirtualMachine.objects.get()
self.assertFalse(vm.deleted)
self.assertEqual(vm.operstate, "ERROR")
for nic in vm.nics.all():
self.assertEqual(nic.state, "ERROR")
# test ext settings:
req = deepcopy(kwargs)
ext_flavor = mfactory.FlavorFactory(
volume_type__disk_template="ext_archipelago", disk=1)
req["flavor"] = ext_flavor
mrapi().CreateInstance.return_value = 42
backend.disk_templates = ["ext"]
backend.save()
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with mocked_quotaholder():
with override_settings(settings, **osettings):
vm = servers.create(**req)
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
self.assertEqual(
kwargs["disks"][0], {
"provider": "archipelago",
"origin": "test_mapfile",
"origin_size": 1000,
"name": vm.volumes.all()[0].backend_volume_uuid,
"foo": "mpaz",
"lala": "lolo",
"size": 1024
})
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"credentials": self.credentials,
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image_id": "safs",
"networks": [],
"metadata": {"foo": "bar"},
"personality": [],
}
# no backend!
mfactory.BackendFactory(offline=True)
self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
mfactory.IPv4SubnetFactory(network__public=True)
mfactory.IPv6SubnetFactory(network__public=True)
backend = mfactory.BackendFactory()
# error in nics
req = deepcopy(kwargs)
req["networks"] = [{"uuid": 42}]
self.assertRaises(faults.ItemNotFound, servers.create, **req)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
# error in enqueue. check the vm is deleted and resources released
mrapi().CreateInstance.side_effect = Exception("ganeti is down")
with mocked_quotaholder():
servers.create(**kwargs)
vm = models.VirtualMachine.objects.get()
self.assertFalse(vm.deleted)
self.assertEqual(vm.operstate, "ERROR")
for nic in vm.nics.all():
self.assertEqual(nic.state, "ERROR")
# test ext settings:
req = deepcopy(kwargs)
vlmt = mfactory.VolumeTypeFactory(disk_template='ext_archipelago')
# Generate 4 specs. 2 prefixed with GNT_EXTP_VOLTYPESPEC_PREFIX
# and 2 with an other prefix that should be omitted
volume_type_specs = [
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='%sbar' % GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='%sfoo' % GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='other-prefx-baz'),
mfactory.VolumeTypeSpecsFactory(
volume_type=vlmt, key='another-prefix-biz'),
]
gnt_prefixed_specs = filter(lambda s: s.key.startswith(
GNT_EXTP_VOLTYPESPEC_PREFIX), volume_type_specs)
ext_flavor = mfactory.FlavorFactory(
volume_type=vlmt,
disk=1)
req["flavor"] = ext_flavor
mrapi().CreateInstance.return_value = 42
backend.disk_templates = ["ext"]
backend.save()
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with mocked_quotaholder():
with override_settings(settings, **osettings):
with patch(
'synnefo.logic.backend_allocator.update_backends_disk_templates' # noqa E265
) as update_disk_templates_mock:
# Check that between the `get_available_backends` call
# and the `update_backend_disk_templates` call
# the backend doesn't change.
update_disk_templates_mock.return_value = [backend]
vm = servers.create(**req)
update_disk_templates_mock.assert_called_once_with([backend])
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
disk_kwargs = {"provider": "archipelago",
"origin": "test_mapfile",
"origin_size": 1000,
"name": vm.volumes.all()[0].backend_volume_uuid,
"foo": "mpaz",
"lala": "lolo",
"size": 1024}
disk_kwargs.update({spec.key[len(GNT_EXTP_VOLTYPESPEC_PREFIX):]:
spec.value
for spec in gnt_prefixed_specs})
self.assertEqual(kwargs["disks"][0], disk_kwargs)
def test_url_resolving(self):
"""Test if URL resolving works properly.
Check if the ADMIN_BASE_URL setting is used by Admin and if we have any
issues with slashes and redirections.
"""
##
# Test 1 - Default Admin URL.
#
# By default, the BASE_PATH for Admin is '/admin/'.
r = resolve('/admin/')
self.assertEqual(r.url_name, 'admin-default')
# If we try to resolve the BASE_PATH without the slash, then we should
# get redirected to the correct ('/admin/') URL.
r = resolve('/admin')
self.assertEqual(r.url_name, 'django.views.generic.simple.redirect_to')
self.assertEqual(r.args, ())
self.assertEqual(r.kwargs, {'url': 'admin/'})
# Any URL that starts with the '/admin' string but has extra characters
# should return 404.
with self.assertRaises(Resolver404):
r = resolve('/adminandoopstoomanychars')
##
# Test 2 - Custom Admin URL with suffix. This tests if URL resolving
# works properly when using a custom ADMIN_BASE_URL with a unique
# suffix.
# Change the ADMIN_BASE_URL and update the URLpatterns of Synnefo.
with override_settings(settings, ADMIN_BASE_URL=URL1):
reload_urlconf()
# Check that the '/admin/' URL no longer works.
with self.assertRaises(Resolver404):
r = resolve('/admin/')
# The new BASE_PATH should be 'rand0m'. Check if the resolved view
# is the expected.
r = resolve('/rand0m/')
self.assertEqual(r.url_name, 'admin-default')
# Check if resolving the BASE_PATH without a slash redirects us
# properly.
r = resolve('/rand0m')
self.assertEqual(r.url_name,
'django.views.generic.simple.redirect_to')
self.assertEqual(r.args, ())
self.assertEqual(r.kwargs, {'url': 'rand0m/'})
# Check if extra characters return 404.
with self.assertRaises(Resolver404):
r = resolve('/rand0mandoopstoomanychars')
##
# Test 3 - Custom Admin URL without suffix. This tests if URL resolving
# works properly when using a custom ADMIN_BASE_URL that points to a
# node only, with no extra suffix.
# Although Admin can be installed in a separate node from the
# Cyclades/Astakos nodes, their packages - and by extension their
# URLPatterns - will be installed in the Admin node. In order to "hide"
# their urls, we will use the Admin urls as our ROOT_URLCONF for this
# part of the test.
with override_settings(settings, ADMIN_BASE_URL=URL2):
reload_urlconf('synnefo_admin.urls')
# Check that hitting the node URL sends us to Admin.
r = resolve('/')
self.assertEqual(r.url_name, 'admin-default')
def test_url_resolving(self):
"""Test if URL resolving works properly.
Check if the ADMIN_BASE_URL setting is used by Admin and if we have any
issues with slashes and redirections.
"""
##
# Test 1 - Default Admin URL.
#
# By default, the BASE_PATH for Admin is '/admin/'.
r = resolve('/admin/')
self.assertEqual(r.url_name, 'admin-default')
# If we try to resolve the BASE_PATH without the slash, then we should
# get redirected to the correct ('/admin/') URL.
r = resolve('/admin')
self.assertEqual(r.url_name, 'django.views.generic.simple.redirect_to')
self.assertEqual(r.args, ())
self.assertEqual(r.kwargs, {'url': 'admin/'})
# Any URL that starts with the '/admin' string but has extra characters
# should return 404.
with self.assertRaises(Resolver404):
r = resolve('/adminandoopstoomanychars')
##
# Test 2 - Custom Admin URL with suffix. This tests if URL resolving
# works properly when using a custom ADMIN_BASE_URL with a unique
# suffix.
# Change the ADMIN_BASE_URL and update the URLpatterns of Synnefo.
with override_settings(settings, ADMIN_BASE_URL=URL1):
reload_urlconf()
# Check that the '/admin/' URL no longer works.
with self.assertRaises(Resolver404):
r = resolve('/admin/')
# The new BASE_PATH should be 'rand0m'. Check if the resolved view
# is the expected.
r = resolve('/rand0m/')
self.assertEqual(r.url_name, 'admin-default')
# Check if resolving the BASE_PATH without a slash redirects us
# properly.
r = resolve('/rand0m')
self.assertEqual(r.url_name,
'django.views.generic.simple.redirect_to')
self.assertEqual(r.args, ())
self.assertEqual(r.kwargs, {'url': 'rand0m/'})
# Check if extra characters return 404.
with self.assertRaises(Resolver404):
r = resolve('/rand0mandoopstoomanychars')
##
# Test 3 - Custom Admin URL without suffix. This tests if URL resolving
# works properly when using a custom ADMIN_BASE_URL that points to a
# node only, with no extra suffix.
# Although Admin can be installed in a separate node from the
# Cyclades/Astakos nodes, their packages - and by extension their
# URLPatterns - will be installed in the Admin node. In order to "hide"
# their urls, we will use the Admin urls as our ROOT_URLCONF for this
# part of the test.
with override_settings(settings, ADMIN_BASE_URL=URL2):
reload_urlconf('synnefo_admin.urls')
# Check that hitting the node URL sends us to Admin.
r = resolve('/')
self.assertEqual(r.url_name, 'admin-default')
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"userid": "test",
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image_id": "safs",
"networks": [],
"metadata": {"foo": "bar"},
"personality": [],
}
# no backend!
mfactory.BackendFactory(offline=True)
self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
mfactory.IPv4SubnetFactory(network__public=True)
mfactory.IPv6SubnetFactory(network__public=True)
backend = mfactory.BackendFactory()
# error in nics
req = deepcopy(kwargs)
req["networks"] = [{"uuid": 42}]
self.assertRaises(faults.ItemNotFound, servers.create, **req)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
# error in enqueue. check the vm is deleted and resources released
mrapi().CreateInstance.side_effect = Exception("ganeti is down")
with mocked_quotaholder():
servers.create(**kwargs)
vm = models.VirtualMachine.objects.get()
self.assertFalse(vm.deleted)
self.assertEqual(vm.operstate, "ERROR")
for nic in vm.nics.all():
self.assertEqual(nic.state, "ERROR")
# test ext settings:
req = deepcopy(kwargs)
ext_flavor = mfactory.FlavorFactory(
volume_type__disk_template="ext_archipelago",
disk=1)
req["flavor"] = ext_flavor
mrapi().CreateInstance.return_value = 42
backend.disk_templates = ["ext"]
backend.save()
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with mocked_quotaholder():
with override_settings(settings, **osettings):
with patch(
'synnefo.logic.backend_allocator.update_backends_disk_templates'
) as update_disk_templates_mock:
# Check that between the `get_available_backends` call
# and the `update_backend_disk_templates` call
# the backend doesn't change.
update_disk_templates_mock.return_value = [backend]
vm = servers.create(**req)
update_disk_templates_mock.assert_called_once_with([backend], ext_flavor)
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
self.assertEqual(kwargs["disks"][0],
{"provider": "archipelago",
"origin": "test_mapfile",
"origin_size": 1000,
"name": vm.volumes.all()[0].backend_volume_uuid,
"foo": "mpaz",
"lala": "lolo",
"size": 1024})
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"credentials": self.credentials,
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image_id": "safs",
"networks": [],
"metadata": {
"foo": "bar"
},
"personality": [],
}
# no backend!
mfactory.BackendFactory(offline=True)
self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
mfactory.IPv4SubnetFactory(network__public=True)
mfactory.IPv6SubnetFactory(network__public=True)
backend = mfactory.BackendFactory()
# error in nics
req = deepcopy(kwargs)
req["networks"] = [{"uuid": 42}]
self.assertRaises(faults.ItemNotFound, servers.create, **req)
self.assertEqual(models.VirtualMachine.objects.count(), 0)
# error in enqueue. check the vm is deleted and resources released
mrapi().CreateInstance.side_effect = Exception("ganeti is down")
with mocked_quotaholder():
servers.create(**kwargs)
vm = models.VirtualMachine.objects.get()
self.assertFalse(vm.deleted)
self.assertEqual(vm.operstate, "ERROR")
for nic in vm.nics.all():
self.assertEqual(nic.state, "ERROR")
# test ext settings:
req = deepcopy(kwargs)
vlmt = mfactory.VolumeTypeFactory(disk_template='ext_archipelago')
# Generate 4 specs. 2 prefixed with GNT_EXTP_VOLTYPESPEC_PREFIX
# and 2 with an other prefix that should be omitted
volume_type_specs = [
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='%sbar' %
GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='%sfoo' %
GNT_EXTP_VOLTYPESPEC_PREFIX),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='other-prefx-baz'),
mfactory.VolumeTypeSpecsFactory(volume_type=vlmt,
key='another-prefix-biz'),
]
gnt_prefixed_specs = filter(
lambda s: s.key.startswith(GNT_EXTP_VOLTYPESPEC_PREFIX),
volume_type_specs)
ext_flavor = mfactory.FlavorFactory(volume_type=vlmt, disk=1)
req["flavor"] = ext_flavor
mrapi().CreateInstance.return_value = 42
backend.disk_templates = ["ext"]
backend.save()
osettings = {
"GANETI_DISK_PROVIDER_KWARGS": {
"archipelago": {
"foo": "mpaz",
"lala": "lolo"
}
}
}
with mocked_quotaholder():
with override_settings(settings, **osettings):
with patch(
'synnefo.logic.backend_allocator.update_backends_disk_templates' # noqa E265
) as update_disk_templates_mock:
# Check that between the `get_available_backends` call
# and the `update_backend_disk_templates` call
# the backend doesn't change.
update_disk_templates_mock.return_value = [backend]
vm = servers.create(**req)
update_disk_templates_mock.assert_called_once_with([backend])
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
disk_kwargs = {
"provider": "archipelago",
"origin": "test_mapfile",
"origin_size": 1000,
"name": vm.volumes.all()[0].backend_volume_uuid,
"foo": "mpaz",
"lala": "lolo",
"size": 1024
}
disk_kwargs.update({
spec.key[len(GNT_EXTP_VOLTYPESPEC_PREFIX):]: spec.value
for spec in gnt_prefixed_specs
})
self.assertEqual(kwargs["disks"][0], disk_kwargs)
def test_create_network_info(self, mrapi):
mrapi().CreateInstance.return_value = 12
# User requested private networks
s1 = mfactory.IPv4SubnetFactory(network__userid="test")
s2 = mfactory.IPv6SubnetFactory(network__userid="test")
# and a public IPv6
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id},
{"uuid": s2.network_id}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', "test",
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
name, args, kwargs = mrapi().CreateInstance.mock_calls[0]
self.assertEqual(len(kwargs["nics"]), 3)
self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)
self.assertEqual(kwargs["nics"][1]["network"], s1.network.backend_id)
self.assertEqual(kwargs["nics"][2]["network"], s2.network.backend_id)
# but fail if others user network
s3 = mfactory.IPv6SubnetFactory(network__userid="test_other")
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s3.network_id}]
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 404)
# User requested public networks
# but no floating IP..
s1 = mfactory.IPv4SubnetFactory(network__public=True)
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id}]
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 409)
# Add one floating IP
fp1 = mfactory.IPv4AddressFactory(userid="test", subnet=s1,
network=s1.network,
floating_ip=True, nic=None)
self.assertEqual(fp1.nic, None)
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id,
"fixed_ip": fp1.address}]
with mocked_quotaholder():
with override_settings(settings, **self.network_settings):
response = self.mypost('servers', "test",
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
fp1 = IPAddress.objects.get(id=fp1.id)
self.assertEqual(fp1.nic.machine_id, server_id)
# check used floating IP
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 409)
# Add more floating IP. but check auto-reserve
fp2 = mfactory.IPv4AddressFactory(userid="test", subnet=s1,
network=s1.network,
floating_ip=True, nic=None)
self.assertEqual(fp2.nic, None)
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id}]
with mocked_quotaholder():
with override_settings(settings, **self.network_settings):
response = self.mypost('servers', "test",
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
fp2 = IPAddress.objects.get(id=fp2.id)
self.assertEqual(fp2.nic.machine_id, server_id)
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
self.assertEqual(len(kwargs["nics"]), 2)
self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)
self.assertEqual(kwargs["nics"][1]["network"], fp2.network.backend_id)
def test_create_network_info(self, mrapi):
mrapi().CreateInstance.return_value = 12
# User requested private networks
s1 = mfactory.IPv4SubnetFactory(network__userid="test")
s2 = mfactory.IPv6SubnetFactory(network__userid="test")
# and a public IPv6
request = deepcopy(self.request)
request["server"]["networks"] = [{
"uuid": s1.network_id
}, {
"uuid": s2.network_id
}]
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', "test", json.dumps(request),
'json')
self.assertEqual(response.status_code, 202)
name, args, kwargs = mrapi().CreateInstance.mock_calls[0]
self.assertEqual(len(kwargs["nics"]), 3)
self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)
self.assertEqual(kwargs["nics"][1]["network"], s1.network.backend_id)
self.assertEqual(kwargs["nics"][2]["network"], s2.network.backend_id)
# but fail if others user network
s3 = mfactory.IPv6SubnetFactory(network__userid="test_other")
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s3.network_id}]
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 404)
# User requested public networks
# but no floating IP..
s1 = mfactory.IPv4SubnetFactory(network__public=True)
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id}]
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 409)
# Add one floating IP
fp1 = mfactory.IPv4AddressFactory(userid="test",
subnet=s1,
network=s1.network,
floating_ip=True,
nic=None)
self.assertEqual(fp1.nic, None)
request = deepcopy(self.request)
request["server"]["networks"] = [{
"uuid": s1.network_id,
"fixed_ip": fp1.address
}]
with mocked_quotaholder():
with override_settings(settings, **self.network_settings):
response = self.mypost('servers', "test", json.dumps(request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
fp1 = IPAddress.objects.get(id=fp1.id)
self.assertEqual(fp1.nic.machine_id, server_id)
# check used floating IP
response = self.mypost('servers', "test", json.dumps(request), 'json')
self.assertEqual(response.status_code, 409)
# Add more floating IP. but check auto-reserve
fp2 = mfactory.IPv4AddressFactory(userid="test",
subnet=s1,
network=s1.network,
floating_ip=True,
nic=None)
self.assertEqual(fp2.nic, None)
request = deepcopy(self.request)
request["server"]["networks"] = [{"uuid": s1.network_id}]
with mocked_quotaholder():
with override_settings(settings, **self.network_settings):
response = self.mypost('servers', "test", json.dumps(request),
'json')
self.assertEqual(response.status_code, 202)
server_id = json.loads(response.content)["server"]["id"]
fp2 = IPAddress.objects.get(id=fp2.id)
self.assertEqual(fp2.nic.machine_id, server_id)
name, args, kwargs = mrapi().CreateInstance.mock_calls[-1]
self.assertEqual(len(kwargs["nics"]), 2)
self.assertEqual(kwargs["nics"][0]["network"], self.net6.backend_id)
self.assertEqual(kwargs["nics"][1]["network"], fp2.network.backend_id)