def test_network_holdings(self):
mfactory.NetworkFactory(userid="user1")
mfactory.NetworkFactory(userid="user2")
user_holdings = {"user2": {"user2": {"cyclades.network.private": 1}}}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
holdings = util.get_db_holdings()
self.assertEqual(holdings["user2"], user_holdings["user2"])
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 setUp(self):
self.mac_prefixes = mfactory.MacPrefixPoolTableFactory()
self.bridges = mfactory.BridgePoolTableFactory(base="link")
self.user = '******'
self.net1 = mfactory.NetworkFactory(userid=self.user)
self.vm1 = mfactory.VirtualMachineFactory(userid=self.user)
self.nic1 = mfactory.NetworkInterfaceFactory(network=self.net1,
machine=self.vm1)
self.nic2 = mfactory.NetworkInterfaceFactory(network=self.net1,
machine=self.vm1)
self.net2 = mfactory.NetworkFactory(userid=self.user)
self.nic3 = mfactory.NetworkInterfaceFactory(network=self.net2)
super(NetworkAPITest, self).setUp()
def test_invalid_mac(self):
network = mfact.NetworkFactory(mac_prefix='zz:bb:c')
backend = mfact.BackendFactory()
self.assertRaises(utils.InvalidMacAddress,
mfact.BackendNetworkFactory,
network=network,
backend=backend)
def test_get_subnet(self):
"""Test get info of a single subnet"""
test_net = mf.NetworkFactory()
test_subnet = mf.IPv4SubnetFactory(network=test_net)
url = join_urls(SUBNETS_URL, str(test_subnet.id))
response = self.get(url, user=test_net.userid)
self.assertSuccess(response)
def test_error_opcode(self, rapi, client):
# Mock getting network, because code will lookup if network exists
# in backend
rapi().GetNetwork.return_value = {}
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
network = mfactory.NetworkFactory()
mfactory.BackendNetworkFactory(network=network,
operstate="ACTIVE")
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE",
network=network)
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_ips(self, client):
network = mfactory.NetworkFactory(subnet='10.0.0.0/24')
bn = mfactory.BackendNetworkFactory(network=network)
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
status='success',
add_reserved_ips=['10.0.0.10', '10.0.0.20'],
remove_reserved_ips=[])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertTrue(pool.is_reserved('10.0.0.10'))
self.assertTrue(pool.is_reserved('10.0.0.20'))
pool.save()
# Release them
msg = self.create_msg(operation='OP_NETWORK_SET_PARAMS',
network=network.backend_id,
cluster=bn.backend.clustername,
add_reserved_ips=[],
remove_reserved_ips=['10.0.0.10', '10.0.0.20'])
update_network(client, msg)
client.basic_ack.assert_called_once()
pool = network.get_pool()
self.assertFalse(pool.is_reserved('10.0.0.10'))
self.assertFalse(pool.is_reserved('10.0.0.20'))
def create_network(self, state=''):
network = models_factory.NetworkFactory()
if state:
network.state = state
network.save()
return network
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_subnet_with_multiple_ip_pools(self):
"""Test create a subnet with multiple IP pools"""
test_net = mf.NetworkFactory()
request = {
'subnet': {
'network_id':
test_net.id,
'cidr':
'10.0.3.0/24',
'ip_version':
4,
'allocation_pools': [{
'start': '10.0.3.2',
'end': '10.0.3.100'
}, {
'start': '10.0.3.200',
'end': '10.0.3.220'
}]
}
}
response = self.post(SUBNETS_URL, test_net.userid, json.dumps(request),
"json")
self.assertSuccess201(response)
resp = json.loads(response.content)['subnet']
self.assertEqual([{
"start": "10.0.3.2",
"end": "10.0.3.100"
}, {
"start": "10.0.3.200",
"end": "10.0.3.220"
}], resp['allocation_pools'])
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_put_network_wrong_data(self):
test_net = dbmf.NetworkFactory()
url = join_urls(NETWORKS_URL, str(test_net.id))
request = {"network": {"wrong_field": "new_name"}}
response = self.put(url,
params=json.dumps(request),
user=test_net.userid)
self.assertEqual(response.status_code, 400)
def test_remove_nic_malformed_2(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user)
request = {'remove': {'attachment': 'nic-%s' % vm.id}}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertBadRequest(response)
def test_add_nic(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user)
request = {'add': {'serverRef': vm.id}}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
def test_list_subnets_data(self):
"""Test list subnets with data"""
test_net = mf.NetworkFactory()
test_subnet_ipv4 = mf.IPv4SubnetFactory(network=test_net)
test_subnet_ipv6 = mf.IPv6SubnetFactory(
network=test_net, ipversion=6, cidr='fd4b:638e:fd7a:f998::/64')
response = self.get(SUBNETS_URL, user=test_net.userid)
self.assertSuccess(response)
def test_update_subnet_name(self):
"""Update the name of a subnet"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'name': 'Updated Name'}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertSuccess(response)
def test_reserve_ip(self):
net1 = mfact.NetworkFactory(subnet='192.168.2.0/24')
net1.reserve_address('192.168.2.12')
pool = net1.get_pool()
self.assertFalse(pool.is_available('192.168.2.12'))
net1.release_address('192.168.2.12')
pool = net1.get_pool()
self.assertTrue(pool.is_available('192.168.2.12'))
def test_update_subnet_dhcp(self):
"""Update the dhcp flag of a subnet"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'enable_dhcp': False}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_update_subnet_with_invalid_name(self):
"""Update a subnet with an invalid name value"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'name': 'a' * 300}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_update_subnet_with_invalid_gateway(self):
"""Update a subnet with an invalid gateway value"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'gateway_ip': '192.168.200.0/24'}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_update_subnet_add_host_routes(self):
"""Update the host routes of a subnet, raises 400 BadRequest"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'host_routes': ['8.8.8.8']}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_update_subnet_cidr(self):
"""Update the cidr of a subnet, raises 400 BadRequest"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'cidr': '192.168.42.0/24'}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_update_subnet_ip_version(self):
"""Update the IP version of a subnet, raises 400 BadRequest"""
test_net = mf.NetworkFactory()
test_sub = mf.IPv4SubnetFactory(network=test_net)
request = {'subnet': {'ip_version': '6'}}
url = join_urls(SUBNETS_URL, str(test_sub.id))
response = self.put(url, test_net.userid, json.dumps(request), "json")
self.assertBadRequest(response)
def test_add_nic_malformed_2(self):
user = '******'
vm = dbmf.VirtualMachineFactory(name='yo', userid=user)
net = dbmf.NetworkFactory(state='ACTIVE', userid=user)
request = {"port": {"device_id": str(vm.id), "name": "port1"}}
response = self.post(PORTS_URL,
params=json.dumps(request),
user=net.userid)
self.assertBadRequest(response)
def test_add_nic_to_public_network(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user, public=True)
request = {'add': {'serverRef': vm.id}}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertFault(response, 403, 'forbidden')
self.assertFalse(mrapi.called)
def test_add_nic_malformed_2(self, mrapi):
user = '******'
vm = mfactory.VirtualMachineFactory(name='yo', userid=user)
net = mfactory.NetworkFactory(state='ACTIVE', userid=user)
request = {'add': {'serveRef': [vm.id, 22]}}
response = self.mypost('networks/%d/action' % net.id, net.userid,
json.dumps(request), 'json')
self.assertBadRequest(response)
self.assertFalse(mrapi.called)
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 test_delete_network(self, mrapi):
net = mfactory.NetworkFactory(deleted=False,
state='ACTIVE',
link="link-10")
with mocked_quotaholder():
response = self.mydelete('networks/%d' % net.id, net.userid)
self.assertEqual(response.status_code, 204)
net = Network.objects.get(id=net.id, userid=net.userid)
self.assertEqual(net.action, 'DESTROY')
mrapi.DeleteNetwork.assert_called()
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_delete_network(self):
test_net = dbmf.NetworkFactory(flavor="CUSTOM")
dbmf.IPv4SubnetFactory(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, 204)
# But not the public network!!
test_net.public = True
test_net.save()
response = self.delete(url, user=test_net.userid)
self.assertFault(response, 403, 'forbidden')
