def test_w_interfaces_configured_in_new_group_net6(self):
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.new_group1.set_net_to_if('eth0', self.network61.name)
self.assertTrue(self.node.set_group(self.new_group1.name))
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.new_group1 = luna.Group(name=self.new_group1.name,
mongo_db=self.db)
self.network61 = luna.Network(name=self.network61.name,
mongo_db=self.db)
group_if_uid = None
for uuid in self.new_group1._json['interfaces']:
group_if_uid = uuid
self.assertEqual(self.node._json['interfaces'][group_if_uid], {
'4': None,
'6': 1
})
self.assertEqual(self.network61._json['freelist'],
[{
'start': 2,
'end': 18446744073709551613
}])
def test_w_interfaces_configured_in_both_groups_same_net(self):
self.group.set_net_to_if('eth0', self.network11.name)
self.new_group1.set_net_to_if('eth0', self.network11.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertTrue(self.node.set_group(self.new_group1.name))
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.new_group1 = luna.Group(name=self.new_group1.name,
mongo_db=self.db)
self.network11 = luna.Network(name=self.network11.name,
mongo_db=self.db)
group_if_uid = None
for uuid in self.new_group1._json['interfaces']:
group_if_uid = uuid
self.assertEqual(self.node._json['interfaces'][group_if_uid], {
'4': 1,
'6': None
})
self.assertEqual(self.network11._json['freelist'], [{
'start': 2,
'end': 65533
}])
def test_add_net_group_net4_node_net6(self):
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MondoDB as a backend.')
self.node.delete()
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.group.set_net_to_if('eth0', self.network.name)
self.node = luna.Node(
group=self.group.name,
mongo_db=self.db,
create=True,
)
for key in self.node._json['interfaces']:
if_dict = self.node._json['interfaces'][key]
self.assertEqual(if_dict, {'4': 1, '6': None})
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
for key in self.node._json['interfaces']:
if_dict = self.node._json['interfaces'][key]
self.assertEqual(if_dict, {'4': 1, '6': 1})
def test_same_ifs_different_nets(self):
self.new_group2 = luna.Group(name='new2',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True)
self.network12 = luna.Network(name="net12",
mongo_db=self.db,
create=True,
NETWORK='10.52.0.0',
PREFIX=16)
self.group.set_net_to_if('eth0', self.network11.name)
self.new_group2.set_net_to_if('eth0', self.network12.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.node.set_ip(interface_name='eth0', ip='10.51.0.2')
self.assertTrue(self.node.set_group(self.new_group2.name))
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.new_group2 = luna.Group(name=self.new_group2.name,
mongo_db=self.db)
self.network11 = luna.Network(name=self.network11.name,
mongo_db=self.db)
self.network12 = luna.Network(name=self.network12.name,
mongo_db=self.db)
group_if_uid = None
for uuid in self.new_group2._json['interfaces']:
group_if_uid = uuid
self.assertEqual(self.node._json['interfaces'][group_if_uid], {
'4': 1,
'6': None
})
self.assertEqual(self.network11._json['freelist'], [{
'start': 1,
'end': 65533
}])
self.assertEqual(self.network12._json['freelist'], [{
'start': 2,
'end': 65533
}])
def test_install_params_w_bmc(self):
self.maxDiff = None
bmcsetup = luna.BMCSetup(
name='bmcsetup1',
mongo_db=self.db,
create=True,
)
self.install_expected_dict['interfaces'].pop('BOOTIF')
self.group.bmcsetup(bmcsetup.name)
self.install_expected_dict['bmcsetup'] = {
'netchannel': 1,
'mgmtchannel': 1,
'userid': 3,
'user': '******',
'password': '******'
}
self.node = luna.Node(
name=self.node.name,
mongo_db=self.db,
)
self.assertEqual(
self.node.install_params,
self.install_expected_dict,
)
def test_install_params_w_nets(self):
self.group.set_net_to_if('eth0', self.net1.name)
self.group.add_interface('BOOTIF')
self.group.set_net_to_if('BOOTIF', self.net2.name)
self.node = luna.Node(
name=self.node.name,
mongo_db=self.db,
)
self.install_expected_dict['interfaces']['BOOTIF']['4'] = {
'ip': '10.51.0.1',
'netmask': '255.255.0.0',
'prefix': '16',
}
self.install_expected_dict['interfaces']['eth0']['4'] = {
'ip': '10.50.0.1',
'netmask': '255.255.0.0',
'prefix': '16',
}
self.assertEqual(
self.node.install_params,
self.install_expected_dict,
)
def test_wo_interfaces_configured(self):
self.assertTrue(self.node.set_group(self.new_group1.name))
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.new_group1 = luna.Group(name=self.new_group1.name,
mongo_db=self.db)
self.assertEqual(self.node._json['group'], self.new_group1.DBRef)
self.assertEqual(self.node._json['_use_']['group'],
{str(self.new_group1._id): 1})
group_if_uid = None
for uuid in self.new_group1._json['interfaces']:
group_if_uid = uuid
self.assertEqual(self.node._json['interfaces'][group_if_uid], {
'4': None,
'6': None
})
self.assertEqual(self.group._json['_usedby_'], {})
def test_boot_params_w_net_and_mac_assigned(self):
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MongoDB as a backend.')
mac = '00:11:22:33:44:55'
self.group.set_net_to_if('eth0', self.net1.name)
self.group.add_interface('BOOTIF')
self.group.set_net_to_if('BOOTIF', self.net2.name)
self.node.set_mac(mac)
self.node = luna.Node(
name=self.node.name,
mongo_db=self.db,
)
self.boot_expected_dict['bootproto'] = 'static'
self.boot_expected_dict['mac'] = mac
self.boot_expected_dict['net']['4'] = {}
self.boot_expected_dict['net']['4']['prefix'] = '16'
self.boot_expected_dict['net']['4']['mask'] = '255.255.0.0'
self.boot_expected_dict['net']['4']['ip'] = '10.51.0.1'
self.assertEqual(
self.node.boot_params,
self.boot_expected_dict,
)
def luna_inventory(self):
osimage_suffix = ".osimages.luna"
group_suffix = ".groups.luna"
inventory = {}
inventory['_meta'] = { 'hostvars': {}}
osimages = {'hosts':[],'vars': {'ansible_connection': 'lchroot' }}
for osimage in luna.list('osimage'):
#osimages['hosts'].append(luna.OsImage(osimage).get('path'))
osimages['hosts'].append(osimage + osimage_suffix)
osimage_path = luna.OsImage(osimage).get('path')
inventory['_meta']['hostvars'][osimage + osimage_suffix]= {
'ansible_host': osimage,
}
inventory['osimages.luna'] = osimages
nodes = {}
inventory['groups.luna'] = {'hosts': []}
for g in luna.list('group'):
group = luna.Group(g)
hosts = []
nodes = group.list_nodes()
for node_name in nodes:
node = luna.Node(node_name)
hosts.append(node_name)
inventory['_meta']['hostvars'][node.show()['name']]={
"bmc_ip":node.get_ip('BMC',version=4)}
inventory[g + group_suffix] = {'hosts': hosts}
inventory['groups.luna']['hosts'].extend(hosts)
return inventory
def test_set_both_ips(self):
self.group.set_net_to_if('eth0', self.network.name)
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertTrue(self.node.set_ip(interface_name='eth0',
ip='10.50.0.2'))
self.assertTrue(self.node.set_ip(interface_name='eth0', ip='fe80::2'))
self.network = luna.Network(name=self.network.name, mongo_db=self.db)
self.network6 = luna.Network(name=self.network6.name, mongo_db=self.db)
self.assertEqual(
self.network._json['freelist'],
[{
'start': 1,
'end': 1
}, {
'start': 3,
'end': 65533
}],
)
self.assertEqual(self.network6._json['freelist'],
[{
'start': 1,
'end': 1
}, {
'start': 3,
'end': 18446744073709551613
}])
def test_ambiguous_ver(self):
self.group.set_net_to_if('eth0', self.network.name)
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertFalse(self.node.get_ip(interface_name='eth0'))
def setUp(
self,
mock_rpm_addmacro,
mock_rpm_transactionset,
):
print
packages = [
{
'VERSION': '3.10',
'RELEASE': '999-el0',
'ARCH': 'x86_64'
},
]
mock_rpm_transactionset.return_value.dbMatch.return_value = packages
self.sandbox = Sandbox()
self.db = self.sandbox.db
self.path = self.sandbox.path
self.cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
self.osimage = luna.OsImage(name='testosimage',
path=self.path,
mongo_db=self.db,
create=True)
self.group = luna.Group(name='testgroup',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True)
self.new_group1 = luna.Group(name='new1',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True)
self.node = luna.Node(group=self.group.name,
mongo_db=self.db,
create=True)
self.network11 = luna.Network(name="net11",
mongo_db=self.db,
create=True,
NETWORK='10.51.0.0',
PREFIX=16)
self.network61 = luna.Network(name="net61",
mongo_db=self.db,
create=True,
NETWORK='fe80::',
PREFIX=64,
version=6)
def luna_node_absent(data):
name = data['name']
try:
node = luna.Node(name=name)
except RuntimeError:
return False, False, name
return not node.delete(), True, name
def test_get_allocated_ips_duplicate_ifs(self):
self.group.add_interface('BMC')
self.group.set_net_to_if('BMC', self.net11.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertEqual(self.group.get_allocated_ips(self.net11), {
'node001-eth0': 1,
'node001-bmc': 2
})
def test_node_del_ip_mistaken(self):
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.node.del_ip('eth0')
self.assertFalse(self.node.del_ip('eth0'))
def test_create_node_exhausted_ips(self):
net = luna.Network(
'net',
mongo_db=self.db,
create=True,
NETWORK='10.50.0.0',
PREFIX=16,
)
tight_net = luna.Network(
'tight_net',
mongo_db=self.db,
create=True,
NETWORK='10.51.0.0',
PREFIX=30,
)
self.group.add_interface('eth1')
self.group.set_net_to_if('eth0', net.name)
self.group.set_net_to_if('eth1', tight_net.name)
node = luna.Node(
group=self.group.name,
mongo_db=self.db,
create=True,
)
with self.assertRaises(RuntimeError):
luna.Node(
group=self.group.name,
mongo_db=self.db,
create=True,
)
tight_net = luna.Network(name=tight_net.name, mongo_db=self.db)
net = luna.Network(name=net.name, mongo_db=self.db)
self.group = luna.Group(name=self.group.name, mongo_db=self.db)
self.assertEqual(tight_net._json['freelist'], [])
self.assertEqual(net._json['freelist'], [{'start': 2, 'end': 65533}])
self.assertEqual(len(self.group._json['_usedby_']['node']), 1)
def test_wrong_version6(self):
interface_uuid = None
for k in self.node._json['interfaces']:
interface_uuid = k
self.group.set_net_to_if('eth0', self.network.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertFalse(
self.node.get_ip(interface_uuid=interface_uuid, version=6))
def test_add_net_w_nodes_6(self):
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.network = luna.Network(name=self.network6.name, mongo_db=self.db)
for key in self.node._json['interfaces']:
if_dict = self.node._json['interfaces'][key]
self.assertEqual(if_dict, {'4': None, '6': 1})
def test_both_vers_confgured(self):
self.group.set_net_to_if('eth0', self.network.name)
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertEqual(self.node.get_ip(interface_name='eth0', version=6),
'fe80::1')
self.assertEqual(self.node.get_ip(interface_name='eth0', version=4),
'10.50.0.1')
def setUp(
self,
mock_rpm_addmacro,
mock_rpm_transactionset,
):
packages = [
{
'VERSION': '3.10',
'RELEASE': '999-el0',
'ARCH': 'x86_64'
},
]
mock_rpm_transactionset.return_value.dbMatch.return_value = packages
print
self.sandbox = Sandbox()
self.db = self.sandbox.db
self.path = self.sandbox.path
self.cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
self.cluster.set('path', self.path)
self.osimage = luna.OsImage(name='testosimage',
path=self.path,
mongo_db=self.db,
create=True)
self.group = luna.Group(
name='testgroup',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True,
)
self.group_new = luna.Group(
name='testgroup_new',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True,
)
self.node = luna.Node(
group=self.group.name,
mongo_db=self.db,
create=True,
)
def test_node_del_ip_wrong_version(self):
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertFalse(self.node.del_ip('eth0', version=4))
node_json = self.db['node'].find_one({'_id': self.node._id})
for k in node_json['interfaces']:
self.assertEqual(node_json['interfaces'][k], {'4': None, '6': 1})
def test_by_name_net6(self):
self.group.set_net_to_if('eth0', self.network6.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertEqual(self.node.get_ip(interface_name='eth0'), 'fe80::1')
self.assertEqual(self.node.get_ip(interface_name='eth0', format='num'),
1)
self.assertEqual(self.node.get_ip(interface_name='eth0', version=6),
'fe80::1')
def test_boot_params_w_bootif_wo_net(self):
self.group.add_interface('BOOTIF')
self.node = luna.Node(
name=self.node.name,
mongo_db=self.db,
)
self.assertEqual(
self.node.boot_params,
self.boot_expected_dict,
)
def test_boot_params_w_net_wo_mac_assigned(self):
self.group.set_net_to_if('eth0', self.net1.name)
self.group.add_interface('BOOTIF')
self.group.set_net_to_if('BOOTIF', self.net2.name)
self.node = luna.Node(
name=self.node.name,
mongo_db=self.db,
)
self.assertEqual(
self.node.boot_params,
self.boot_expected_dict,
)
def test_change_mac(self):
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MongoDB as a backend.')
self.node.set_mac('00:01:02:aa:bb:cc')
node2 = luna.Node(
group=self.group.name,
mongo_db=self.db,
create=True,
)
node2.set_mac('00:01:02:aa:bb:cc')
d = self.db['mac'].find({'mac': '00:01:02:aa:bb:cc'})
self.assertEqual(d.count(), 1)
for e in d:
self.assertEqual(node2.DBRef, e['node'])
def luna_inventory(self):
inventory = {}
osimages = {'hosts': [], 'vars': {'ansible_connection': 'lchroot'}}
for osimage in luna.list('osimage'):
#osimages['hosts'].append(luna.OsImage(osimage).get('path'))
osimages['hosts'].append(osimage)
inventory['osimages'] = osimages
nodes = {}
for n in luna.list('node'):
node = luna.Node(n).show()
group = node['group'].replace("[", "").replace("]", "")
if group in inventory:
inventory[group]['hosts'].append(node['name'])
else:
inventory[group] = {'hosts': [node['name']], 'vars': {}}
return inventory
def test_create_named_node(self):
node = luna.Node(
name='n01',
group=self.group.name,
mongo_db=self.db,
create=True,
)
doc = self.db['node'].find_one({'_id': node._id})
expected = {
'name': 'n01',
}
for attr in expected:
self.assertEqual(doc[attr], expected[attr])
def test_node_del_ip_net4(self):
self.group.set_net_to_if('eth0', self.network.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.node.del_ip('eth0')
net_json = self.db['network'].find_one({'_id': self.network._id})
node_json = self.db['node'].find_one({'_id': self.node._id})
for if_uuid in node_json['interfaces']:
if_dict = node_json['interfaces'][if_uuid]
self.assertEqual(if_dict, {'4': None, '6': None})
self.assertEqual(net_json['freelist'], [{'start': 1, 'end': 65533L}])
def test_delete_node(self):
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MongoDB as a backend.')
node = luna.Node(
name='n02',
group=self.group.name,
mongo_db=self.db,
create=True,
)
nodeid = node._id
node.delete()
doc = self.db['node'].find_one({'_id': nodeid})
self.assertIsNone(doc)
def test_set_ip_force(self):
self.group.set_net_to_if('eth0', self.network.name)
self.node = luna.Node(name=self.node.name, mongo_db=self.db)
self.assertTrue(
self.node.set_ip(interface_name='eth0', ip='10.50.0.2',
force=True))
self.network = luna.Network(name=self.network.name, mongo_db=self.db)
self.assertEqual(
self.network._json['freelist'],
[{
'start': 3,
'end': 65533
}],
)