def test_get_default_nic_networkgroups(self):
cluster = self.env.create_cluster(api=True)
node = self.env.create_node(api=True)
node_db = self.env.nodes[0]
admin_nic = node_db.admin_interface
other_iface = self.db.query(NodeNICInterface).filter_by(
node_id=node['id']
).filter(
not_(NodeNICInterface.id == admin_nic.id)
).first()
interfaces = deepcopy(node_db.meta['interfaces'])
# allocate ip from admin subnet
admin_ip = str(IPNetwork(
NetworkManager.get_admin_network_group().cidr)[0])
for interface in interfaces:
if interface['mac'] == admin_nic.mac:
# reset admin ip for previous admin interface
interface['ip'] = None
elif interface['mac'] == other_iface.mac:
# set new admin interface
interface['ip'] = admin_ip
node_db.meta['interfaces'] = interfaces
self.app.put(
reverse('NodeCollectionHandler'),
json.dumps([{
'mac': admin_nic.mac,
'meta': node_db.meta,
'is_agent': True,
'cluster_id': cluster["id"]
}]),
headers=self.default_headers,
expect_errors=True
)
new_main_nic_id = node_db.admin_interface.id
self.assertEquals(new_main_nic_id, other_iface.id)
self.assertEquals(
other_iface.assigned_networks,
NovaNetworkManager.get_default_nic_networkgroups(
node_db, other_iface))
self.assertEquals(
self.db.query(
NodeNICInterface).get(admin_nic.id).assigned_networks,
NovaNetworkManager.get_default_nic_networkgroups(
node_db, admin_nic))
def test_cluster_create_no_ip_addresses(self):
"""Two clusters having same networks updated to use full CIDR is ok"""
cluster = self.env.create_cluster(
api=True,
net_provider=consts.CLUSTER_NET_PROVIDERS.nova_network)
cluster_db = self.db.query(Cluster).get(cluster["id"])
cluster2 = self.env.create_cluster(
api=True,
net_provider=consts.CLUSTER_NET_PROVIDERS.nova_network,
release_id=cluster_db.release.id)
cluster2_db = self.db.query(Cluster).get(cluster2["id"])
for clstr in (cluster_db, cluster2_db):
management_net = self.db.query(NetworkGroup).filter_by(
name="management",
group_id=objects.Cluster.get_default_group(clstr).id
).first()
NovaNetworkManager.update(
clstr,
{
"networks": [
{
"name": "management",
"ip_ranges": [
["192.168.0.2", "192.168.255.254"]
],
"id": management_net.id,
"cluster_id": clstr.id,
"vlan_start": 101,
"cidr": "192.168.0.0/16",
"gateway": "192.168.0.1"
}
]
}
)
cluster1_nets = self._get_cluster_networks(cluster["id"])
cluster2_nets = self._get_cluster_networks(cluster2["id"])
for net1, net2 in zip(cluster1_nets, cluster2_nets):
for f in ('group_id', 'id'):
del net1[f]
del net2[f]
cluster1_nets = sorted(cluster1_nets, key=lambda n: n['name'])
cluster2_nets = sorted(cluster2_nets, key=lambda n: n['name'])
self.assertEquals(cluster1_nets, cluster2_nets)
def test_get_default_nic_assignment(self):
admin_nic_id = self.env.network_manager.get_admin_interface(
self.node_db
).id
admin_nets = [n.name for n in self.db.query(
NodeNICInterface).get(admin_nic_id).assigned_networks_list]
other_nic = self.db.query(NodeNICInterface).filter_by(
node_id=self.node_db.id
).filter(
not_(NodeNICInterface.id == admin_nic_id)
).first()
other_nets = [n.name for n in other_nic.assigned_networks_list]
nics = NovaNetworkManager.get_default_interfaces_configuration(
self.node_db)
def_admin_nic = [n for n in nics if n['id'] == admin_nic_id]
def_other_nic = [n for n in nics if n['id'] == other_nic.id]
self.assertEqual(len(def_admin_nic), 1)
self.assertEqual(len(def_other_nic), 1)
self.assertEqual(
set(admin_nets),
set([n['name'] for n in def_admin_nic[0]['assigned_networks']]))
self.assertEqual(
set(other_nets),
set([n['name'] for n in def_other_nic[0]['assigned_networks']]))
def test_get_default_nic_assignment(self):
admin_nic_id = self.env.network_manager.get_admin_interface(
self.node_db).id
admin_nets = [
n.name for n in self.db.query(NodeNICInterface).get(
admin_nic_id).assigned_networks_list
]
other_nic = self.db.query(NodeNICInterface).filter_by(
node_id=self.node_db.id).filter(
not_(NodeNICInterface.id == admin_nic_id)).first()
other_nets = [n.name for n in other_nic.assigned_networks_list]
nics = NovaNetworkManager.get_default_interfaces_configuration(
self.node_db)
def_admin_nic = [n for n in nics if n['id'] == admin_nic_id]
def_other_nic = [n for n in nics if n['id'] == other_nic.id]
self.assertEqual(len(def_admin_nic), 1)
self.assertEqual(len(def_other_nic), 1)
self.assertEqual(
set(admin_nets),
set([n['name'] for n in def_admin_nic[0]['assigned_networks']]))
self.assertEqual(
set(other_nets),
set([n['name'] for n in def_other_nic[0]['assigned_networks']]))
def test_cluster_create_no_ip_addresses(self):
"""In this test we check that no error is occured
if two clusters will have same networks updated to use
full CIDR
"""
cluster = self.env.create_cluster(api=True)
cluster_db = self.db.query(Cluster).get(cluster["id"])
cluster2 = self.env.create_cluster(api=True,
release=cluster_db.release.id)
cluster2_db = self.db.query(Cluster).get(cluster2["id"])
for clstr in (cluster_db, cluster2_db):
management_net = self.db.query(NetworkGroup).filter_by(
name="management",
cluster_id=clstr.id
).first()
NovaNetworkManager.update(
clstr,
{
"networks": [
{
"network_size": 65536,
"name": "management",
"ip_ranges": [
["192.168.0.2", "192.168.255.254"]
],
"amount": 1,
"id": management_net.id,
"netmask": "255.255.255.0",
"cluster_id": clstr.id,
"vlan_start": 101,
"cidr": "192.168.0.0/16",
"gateway": "192.168.0.1"
}
]
}
)
cluster1_nets = self._get_cluster_networks(cluster["id"])
cluster2_nets = self._get_cluster_networks(cluster2["id"])
for net1, net2 in zip(cluster1_nets, cluster2_nets):
for f in ('cluster_id', 'id'):
del net1[f]
del net2[f]
self.assertEquals(cluster1_nets, cluster2_nets)
def test_get_default_nic_networkgroups(self):
admin_nic = self.node_db.admin_interface
other_iface = self.db.query(NodeNICInterface).filter_by(
node_id=self.node_db.id
).filter(
not_(NodeNICInterface.id == admin_nic.id)
).first()
self.assertEquals(
other_iface.assigned_networks_list,
NovaNetworkManager.get_default_nic_networkgroups(
self.node_db, other_iface))
self.assertEquals(
self.db.query(
NodeNICInterface).get(admin_nic.id).assigned_networks_list,
NovaNetworkManager.get_default_nic_networkgroups(
self.node_db, admin_nic))
def PUT(self, cluster_id):
""":returns: JSONized Task object.
:http: * 202 (network checking task created)
* 404 (cluster not found in db)
"""
data = json.loads(web.data())
if data.get("networks"):
data["networks"] = [
n for n in data["networks"] if n.get("name") != "fuelweb_admin"
]
cluster = self.get_object_or_404(Cluster, cluster_id)
self.check_net_provider(cluster)
self.check_if_network_configuration_locked(cluster)
task_manager = CheckNetworksTaskManager(cluster_id=cluster.id)
task = task_manager.execute(data)
if task.status != 'error':
try:
if 'networks' in data:
self.validator.validate_networks_update(
json.dumps(data)
)
if 'dns_nameservers' in data:
self.validator.validate_dns_servers_update(
json.dumps(data)
)
NovaNetworkManager.update(cluster, data)
except web.webapi.badrequest as exc:
TaskHelper.set_error(task.uuid, exc.data)
logger.error(traceback.format_exc())
except Exception as exc:
TaskHelper.set_error(task.uuid, exc)
logger.error(traceback.format_exc())
data = build_json_response(TaskHandler.render(task))
if task.status == 'error':
db().rollback()
else:
db().commit()
raise web.accepted(data=data)
def test_cluster_create_no_ip_addresses(self):
"""In this test we check that no error is occured
if two clusters will have same networks updated to use
full CIDR
"""
cluster = self.env.create_cluster(api=True)
cluster_db = self.db.query(Cluster).get(cluster["id"])
cluster2 = self.env.create_cluster(api=True, release_id=cluster_db.release.id)
cluster2_db = self.db.query(Cluster).get(cluster2["id"])
for clstr in (cluster_db, cluster2_db):
management_net = (
self.db.query(NetworkGroup)
.filter_by(name="management", group_id=objects.Cluster.get_default_group(clstr).id)
.first()
)
NovaNetworkManager.update(
clstr,
{
"networks": [
{
"name": "management",
"ip_ranges": [["192.168.0.2", "192.168.255.254"]],
"id": management_net.id,
"cluster_id": clstr.id,
"vlan_start": 101,
"cidr": "192.168.0.0/16",
"gateway": "192.168.0.1",
}
]
},
)
cluster1_nets = self._get_cluster_networks(cluster["id"])
cluster2_nets = self._get_cluster_networks(cluster2["id"])
for net1, net2 in zip(cluster1_nets, cluster2_nets):
for f in ("group_id", "id"):
del net1[f]
del net2[f]
cluster1_nets = sorted(cluster1_nets, key=lambda n: n["name"])
cluster2_nets = sorted(cluster2_nets, key=lambda n: n["name"])
self.assertEquals(cluster1_nets, cluster2_nets)
def test_cluster_create_no_ip_addresses(self):
"""In this test we check that no error is occured
if two clusters will have same networks updated to use
full CIDR
"""
cluster = self.env.create_cluster(api=True)
cluster_db = self.db.query(Cluster).get(cluster["id"])
cluster2 = self.env.create_cluster(api=True,
release_id=cluster_db.release.id)
cluster2_db = self.db.query(Cluster).get(cluster2["id"])
for clstr in (cluster_db, cluster2_db):
management_net = self.db.query(NetworkGroup).filter_by(
name="management",
cluster_id=clstr.id
).first()
NovaNetworkManager.update(
clstr,
{
"networks": [
{
"name": "management",
"ip_ranges": [
["192.168.0.2", "192.168.255.254"]
],
"id": management_net.id,
"cluster_id": clstr.id,
"vlan_start": 101,
"cidr": "192.168.0.0/16",
"gateway": "192.168.0.1"
}
]
}
)
cluster1_nets = self._get_cluster_networks(cluster["id"])
cluster2_nets = self._get_cluster_networks(cluster2["id"])
for net1, net2 in zip(cluster1_nets, cluster2_nets):
for f in ('cluster_id', 'id'):
del net1[f]
del net2[f]
self.assertEqual(cluster1_nets, cluster2_nets)
def test_cluster_create_no_ip_addresses(self):
"""Two clusters having same networks updated to use full CIDR is ok"""
cluster = self.env.create_cluster(
api=True, net_provider=consts.CLUSTER_NET_PROVIDERS.nova_network)
cluster_db = self.db.query(Cluster).get(cluster["id"])
cluster2 = self.env.create_cluster(
api=True,
net_provider=consts.CLUSTER_NET_PROVIDERS.nova_network,
release_id=cluster_db.release.id)
cluster2_db = self.db.query(Cluster).get(cluster2["id"])
for clstr in (cluster_db, cluster2_db):
management_net = self.db.query(NetworkGroup).filter_by(
name="management",
group_id=objects.Cluster.get_default_group(clstr).id).first()
NovaNetworkManager.update(
clstr, {
"networks":
[{
"name": "management",
"ip_ranges": [["192.168.0.2", "192.168.255.254"]],
"id": management_net.id,
"cluster_id": clstr.id,
"vlan_start": 101,
"cidr": "192.168.0.0/16",
"gateway": "192.168.0.1"
}]
})
cluster1_nets = self._get_cluster_networks(cluster["id"])
cluster2_nets = self._get_cluster_networks(cluster2["id"])
for net1, net2 in zip(cluster1_nets, cluster2_nets):
for f in ('group_id', 'id'):
del net1[f]
del net2[f]
cluster1_nets = sorted(cluster1_nets, key=lambda n: n['name'])
cluster2_nets = sorted(cluster2_nets, key=lambda n: n['name'])
self.assertEquals(cluster1_nets, cluster2_nets)
