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_create_network_check(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX=24)
net = luna.Network(name='testnet', mongo_db=self.db)
self.assertIsInstance(net, luna.Network)
self.assertEqual(net.maxbits, 32)
self.assertEqual(net.version, 4)
expected_dict = {
'name': 'testnet',
'freelist': [{
u'start': 1,
u'end': 253L
}],
'ns_ip': 254,
'PREFIX': 24,
'_usedby_': {},
'version': 4,
'NETWORK': 2886729984L
}
doc = self.db['network'].find_one({'name': net.name})
for key in expected_dict.keys():
self.assertEqual(doc[key], expected_dict[key])
def test_create_network_check_ipv6(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='fd12:3456:789a:1::1',
PREFIX=64,
version=6)
net = luna.Network(name='testnet', mongo_db=self.db)
self.assertIsInstance(net, luna.Network)
self.assertEqual(net.maxbits, 128)
self.assertEqual(net.version, 6)
expected_dict = {
'name': 'testnet',
'freelist': [{
'start': '1',
'end': '18446744073709551613'
}],
'ns_ip': '18446744073709551614',
'PREFIX': 64,
'_usedby_': {},
'version': 6,
'NETWORK': '336389205813283084628800618700287770624'
}
doc = self.db['network'].find_one({'name': net.name})
for key in expected_dict.keys():
self.assertEqual(doc[key], expected_dict[key])
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 test_read_network(self):
luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX='24')
net = luna.Network(name='testnet', mongo_db=self.db)
self.assertIsInstance(net, luna.Network)
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_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_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_change_switch(self):
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MongoDB as a backend.')
net = luna.Network(
'testnet',
mongo_db=self.db,
create=True,
NETWORK='10.50.0.0',
PREFIX=16,
)
switch1 = luna.Switch(
'test1',
network=net.name,
mongo_db=self.db,
create=True,
)
switch2 = luna.Switch(
'test2',
network=net.name,
mongo_db=self.db,
create=True,
)
self.node.set_switch(switch1.name)
self.node.set_switch(switch2.name)
d1 = self.db['node'].find_one({'name': self.node.name})
d2 = self.db['switch'].find_one({'name': switch1.name})
d3 = self.db['switch'].find_one({'name': switch2.name})
self.assertEqual(d1['switch'], switch2.DBRef)
self.assertEqual(len(d2['_usedby_']), 0)
self.assertEqual(len(d3['_usedby_']['node']), 1)
self.assertEqual(d1['switch'], switch2.DBRef)
def test_create_network_with_defaults(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX='24')
self.assertIsInstance(net, luna.Network)
def luna_network_present(data):
name = data['name']
network = data['network']
prefix = data['prefix']
ns_hostname = data['ns_hostname']
ns_ip = data['ns_ip']
changed = False
try:
net = luna.Network(name=name)
except RuntimeError:
net = luna.Network(name=name,
create=True,
NETWORK=network,
PREFIX=prefix,
ns_hostname=ns_hostname,
ns_ip=ns_ip)
changed = True
version = luna.utils.ip.get_ip_version(network)
res = True
if ns_hostname and (ns_hostname != net.get('ns_hostname')):
changed = True
res &= net.set('ns_hostname', ns_hostname)
for key in ['comment', 'include', 'rev_include']:
if data[key] != net.get(key):
changed = True
res &= net.set(key, data[key])
if ns_ip and (ns_ip != net.get('ns_ip')):
changed = True
res &= net.set('ns_ip', ns_ip)
if luna.utils.ip.ntoa(
luna.utils.ip.get_num_subnet(network, prefix, version),
version) != net.get('NETWORK'):
changed = True
res &= net.set('NETWORK', network)
if prefix != net.get('PREFIX'):
changed = True
res &= net.set('PREFIX', prefix)
return False, changed, str(net)
def test_create_network_ipv6(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='fd12:3456:789a:1::1',
PREFIX='64',
version=6)
self.assertIsInstance(net, luna.Network)
def test_w_another_net(self):
net1 = luna.Network(name="net1",
mongo_db=self.db,
create=True,
NETWORK='10.149.0.0',
PREFIX=16)
self.group.set_net_to_if('eth0', net1.name)
self.assertEqual(self.group.get_macs(self.network), {})
def luna_network_absent(data):
name = data['name']
try:
net = luna.Network(name)
except RuntimeError:
return False, False, name
return not net.delete(), True, name
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_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_create_duplicate_network(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX=24)
self.assertRaises(RuntimeError,
luna.Network,
name='testnet2',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.1',
PREFIX=24)
def test_set_wrong_range(self):
self.cluster.set('frontend_address', '10.11.255.254')
ret = self.cluster.makedhcp_config(net_name=self.net11.name,
start_ip='10.11.0.2',
end_ip='10.11.0.3')
self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db)
self.assertEqual(self.net11._json['freelist'], [{
'start': 3,
'end': 65533
}])
self.assertEqual(ret, {})
def test_create_duplicate_network_ipv6(self):
net = luna.Network(name='testnet',
mongo_db=self.db,
create=True,
NETWORK='fd12:3456:789a:1::1',
PREFIX='64',
version=6)
self.assertRaises(RuntimeError,
luna.Network,
name='testnet2',
mongo_db=self.db,
create=True,
NETWORK='fd12:3456:789a:1::2',
PREFIX=64)
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
}],
)
def setUp(self):
print
self.sandbox = Sandbox()
self.db = self.sandbox.db
self.path = self.sandbox.path
cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
self.network = luna.Network(mongo_db=self.db,
create=True,
name='cluster',
NETWORK='10.141.0.0',
PREFIX=16)
def test_set_wrong_ip(self):
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.set_ip(interface_name='eth0', ip='10.40.0.1'))
self.network = luna.Network(name=self.network.name, mongo_db=self.db)
self.assertEqual(
self.network._json['freelist'],
[{
'start': 2,
'end': 65533
}],
)
self.assertEqual(self.node.get_ip(interface_name='eth0'), '10.50.0.1')
def setUp(self):
self.bind = create_datastore('mim:///luna')
self.db = self.bind.db.luna
self.path = '/tmp/luna'
if not os.path.exists(self.path):
os.makedirs(self.path)
cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
self.net = luna.Network(name='test',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX='24',
ns_hostname='controller',
ns_ip='172.16.1.254')
def setUp(self):
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.net = luna.Network(name='test',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX='24',
ns_hostname='controller',
ns_ip='172.16.1.254')
def test_add_remove_net6_to_if(self):
start_dict = self.db['group'].find_one({'_id': self.group._id})
net6 = luna.Network(
name='net6',
mongo_db=self.db,
)
show_if_expected = {
'name': 'eth0',
'options': '',
'network': {
'4': {
'prefix': '',
'netmask': '',
'name': '',
'network': ''
},
'6': {
'prefix': '',
'netmask': '',
'name': '',
'network': ''
},
},
}
self.group.set_net_to_if('eth0', net6.name)
show_if_expected['network']['6']['name'] = 'net6'
show_if_expected['network']['6']['netmask'] = 'ffff:ffff:ffff:ffff::'
show_if_expected['network']['6']['prefix'] = '64'
show_if_expected['network']['6']['network'] = 'fe80::'
self.assertEqual(self.group.show_if('eth0'), show_if_expected)
self.group.del_net_from_if('eth0')
# check if we get the same dictionary at the and
end_dict = self.db['group'].find_one({'_id': self.group._id})
self.assertEqual(start_dict, end_dict)
def setUp(self):
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.net = luna.Network(name='test',
mongo_db=self.db,
create=True,
NETWORK='fdee:172:30:128::',
PREFIX=64,
ns_hostname='controller',
ns_ip='fdee:172:30:128::254:254',
version=6)
def test_make_config_basic(self):
self.cluster.set('frontend_address', '10.11.255.254')
ret = self.cluster.makedhcp_config(net_name=self.net11.name,
start_ip='10.11.128.1',
end_ip='10.11.129.254')
self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db)
self.assertEqual(self.net11._json['freelist'], [{
'start': 3,
'end': 32768
}, {
'start': 33279,
'end': 65533
}])
hmac_key = ret.pop('hmac_key')
self.assertTrue(len(hmac_key) > 1)
self.assertEqual(
ret, {
'network': '10.11.0.0',
'dhcp_start': '10.11.128.1',
'dhcp_end': '10.11.129.254',
'reservations': {
'node002': {
'ip': '10.11.0.2',
'mac': '01:11:22:33:44:55'
},
'node001': {
'ip': '10.11.0.1',
'mac': '00:11:22:33:44:55'
},
},
'netmask': '255.255.0.0',
'frontend_ip': '10.11.255.254',
'frontend_port': '7050',
'protocol': 'http',
})
def test_change_to_wrong_range(self):
self.cluster.set('frontend_address', '10.11.255.254')
ret = self.cluster.makedhcp_config(net_name=self.net11.name,
start_ip='10.11.128.1',
end_ip='10.11.129.254')
ret = self.cluster.makedhcp_config(net_name=self.net11.name,
start_ip='10.11.0.2',
end_ip='10.11.0.4')
self.assertEqual(ret, {})
self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db)
self.assertEqual(self.cluster.get('dhcp_range_start'), '10.11.128.1')
self.assertEqual(self.cluster.get('dhcp_range_end'), '10.11.129.254')
self.assertEqual(self.net11._json['freelist'], [{
'start': 3,
'end': 32768
}, {
'start': 33279,
'end': 65533
}])
def test_set_ip_by_uuid(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.assertTrue(
self.node.set_ip(interface_uuid=interface_uuid, ip='10.50.0.2'))
self.network = luna.Network(name=self.network.name, mongo_db=self.db)
self.assertEqual(
self.network._json['freelist'],
[{
'start': 1,
'end': 1
}, {
'start': 3,
'end': 65533
}],
)
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()
if self.sandbox.dbtype != 'mongo':
raise unittest.SkipTest(
'This test can be run only with MongoDB as a backend.')
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.group1 = luna.Group(name='testgroup1',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['eth0'],
create=True)
self.group2 = luna.Group(name='testgroup2',
osimage=self.osimage.name,
mongo_db=self.db,
interfaces=['BOOTIF'],
create=True)
self.net11 = luna.Network(name='net11',
NETWORK='10.11.0.0',
PREFIX=16,
mongo_db=self.db,
create=True)
self.group1.set_net_to_if('eth0', self.net11.name)
self.group2.set_net_to_if('BOOTIF', self.net11.name)
self.node1 = luna.Node(group=self.group1.name,
mongo_db=self.db,
create=True)
self.node2 = luna.Node(group=self.group2.name,
mongo_db=self.db,
create=True)
self.node1.set_mac('00:11:22:33:44:55')
self.node2.set_mac('01:11:22:33:44:55')
self.group1 = luna.Group(name=self.group1.name, mongo_db=self.db)
self.group2 = luna.Group(name=self.group2.name, mongo_db=self.db)
self.net11 = luna.Network(name=self.net11.name, mongo_db=self.db)
self.node1 = luna.Node(name=self.node1.name, mongo_db=self.db)
self.node2 = luna.Node(name=self.node2.name, mongo_db=self.db)
