def test_gen_conf_mtu(self, m_get_phys_by_mac):
"""Test rendering with/without MTU"""
self.maxDiff = None
# empty ETH0_MTU
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'ETH0_MTU': '', }
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'match': {'macaddress': MACADDR},
'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context)
self.assertEqual(net.gen_conf(), expected)
# set ETH0_MTU
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'ETH0_MTU': '1280', }
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'mtu': '1280',
'match': {'macaddress': MACADDR},
'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context)
self.assertEqual(net.gen_conf(), expected)
def test_gen_conf_ipv6address(self, m_get_phys_by_mac):
"""Test rendering with/without IPv6 address"""
self.maxDiff = None
# empty ETH0_IP6, ETH0_IP6_ULA, ETH0_IP6_PREFIX_LENGTH
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'ETH0_IP6': '',
'ETH0_IP6_ULA': '',
'ETH0_IP6_PREFIX_LENGTH': '',
}
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'match': {
'macaddress': MACADDR
},
'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]
}
}
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
# set ETH0_IP6, ETH0_IP6_ULA, ETH0_IP6_PREFIX_LENGTH
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'ETH0_IP6': IP6_GLOBAL,
'ETH0_IP6_PREFIX_LENGTH': IP6_PREFIX,
'ETH0_IP6_ULA': IP6_ULA,
}
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'match': {
'macaddress': MACADDR
},
'addresses': [
IP_BY_MACADDR + '/' + IP4_PREFIX,
IP6_GLOBAL + '/' + IP6_PREFIX,
IP6_ULA + '/' + IP6_PREFIX
]
}
}
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
def test_gen_conf_dns(self, m_get_phys_by_mac):
"""Test rendering with/without DNS server, search domain"""
self.maxDiff = None
# empty DNS, ETH0_DNS, ETH0_SEARCH_DOMAIN
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'DNS': '',
'ETH0_DNS': '',
'ETH0_SEARCH_DOMAIN': '',
}
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'match': {
'macaddress': MACADDR
},
'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]
}
}
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
# set DNS, ETH0_DNS, ETH0_SEARCH_DOMAIN
context = {
'ETH0_MAC': '02:00:0a:12:01:01',
'DNS': '1.2.3.8',
'ETH0_DNS': '1.2.3.6 1.2.3.7',
'ETH0_SEARCH_DOMAIN': 'example.com example.org',
}
for nic in self.system_nics:
expected = {
'version': 2,
'ethernets': {
nic: {
'nameservers': {
'addresses': ['1.2.3.6', '1.2.3.7', '1.2.3.8'],
'search': ['example.com', 'example.org']
},
'match': {
'macaddress': MACADDR
},
'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]
}
}
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
def test_gen_conf_dns(self, m_get_phys_by_mac):
"""Test rendering with/without DNS server, search domain"""
self.maxDiff = None
# empty DNS, ETH0_DNS, ETH0_SEARCH_DOMAIN
context = {
"ETH0_MAC": "02:00:0a:12:01:01",
"DNS": "",
"ETH0_DNS": "",
"ETH0_SEARCH_DOMAIN": "",
}
for nic in self.system_nics:
expected = {
"version": 2,
"ethernets": {
nic: {
"match": {"macaddress": MACADDR},
"addresses": [IP_BY_MACADDR + "/" + IP4_PREFIX],
}
},
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
# set DNS, ETH0_DNS, ETH0_SEARCH_DOMAIN
context = {
"ETH0_MAC": "02:00:0a:12:01:01",
"DNS": "1.2.3.8",
"ETH0_DNS": "1.2.3.6 1.2.3.7",
"ETH0_SEARCH_DOMAIN": "example.com example.org",
}
for nic in self.system_nics:
expected = {
"version": 2,
"ethernets": {
nic: {
"nameservers": {
"addresses": ["1.2.3.6", "1.2.3.7", "1.2.3.8"],
"search": ["example.com", "example.org"],
},
"match": {"macaddress": MACADDR},
"addresses": [IP_BY_MACADDR + "/" + IP4_PREFIX],
}
},
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
def test_gen_conf_ipv6address(self, m_get_phys_by_mac):
"""Test rendering with/without IPv6 address"""
self.maxDiff = None
# empty ETH0_IP6, ETH0_IP6_ULA, ETH0_IP6_PREFIX_LENGTH
context = {
"ETH0_MAC": "02:00:0a:12:01:01",
"ETH0_IP6": "",
"ETH0_IP6_ULA": "",
"ETH0_IP6_PREFIX_LENGTH": "",
}
for nic in self.system_nics:
expected = {
"version": 2,
"ethernets": {
nic: {
"match": {"macaddress": MACADDR},
"addresses": [IP_BY_MACADDR + "/" + IP4_PREFIX],
}
},
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
# set ETH0_IP6, ETH0_IP6_ULA, ETH0_IP6_PREFIX_LENGTH
context = {
"ETH0_MAC": "02:00:0a:12:01:01",
"ETH0_IP6": IP6_GLOBAL,
"ETH0_IP6_PREFIX_LENGTH": IP6_PREFIX,
"ETH0_IP6_ULA": IP6_ULA,
}
for nic in self.system_nics:
expected = {
"version": 2,
"ethernets": {
nic: {
"match": {"macaddress": MACADDR},
"addresses": [
IP_BY_MACADDR + "/" + IP4_PREFIX,
IP6_GLOBAL + "/" + IP6_PREFIX,
IP6_ULA + "/" + IP6_PREFIX,
],
}
},
}
m_get_phys_by_mac.return_value = {MACADDR: nic}
net = ds.OpenNebulaNetwork(context, mock.Mock())
self.assertEqual(net.gen_conf(), expected)
def test_eth0_override(self):
context = {
'DNS': '1.2.3.8',
'ETH0_IP': '10.18.1.1',
'ETH0_NETWORK': '10.18.0.0',
'ETH0_MASK': '255.255.0.0',
'ETH0_GATEWAY': '1.2.3.5',
'ETH0_DOMAIN': 'example.com',
'ETH0_DNS': '1.2.3.6 1.2.3.7',
'ETH0_MAC': '02:00:0a:12:01:01'
}
for nic in self.system_nics:
expected = dedent("""\
auto lo
iface lo inet loopback
auto {dev}
iface {dev} inet static
#hwaddress {macaddr}
address 10.18.1.1
network 10.18.0.0
netmask 255.255.0.0
gateway 1.2.3.5
dns-search example.com
dns-nameservers 1.2.3.8 1.2.3.6 1.2.3.7
""").format(dev=nic, macaddr=MACADDR)
net = ds.OpenNebulaNetwork(context,
system_nics_by_mac={MACADDR: nic})
self.assertEqual(expected, net.gen_conf())
def test_network_interfaces(self, m_get_phys_by_mac):
m_get_phys_by_mac.return_value = {'02:00:0a:12:01:01': 'eth0'}
populate_context_dir(self.seed_dir, {'ETH0_IP': '1.2.3.4'})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue('1.2.3.4' in results['network-interfaces'])
def test_eth0_override(self):
self.maxDiff = None
context = {
'DNS': '1.2.3.8',
'ETH0_DNS': '1.2.3.6 1.2.3.7',
'ETH0_GATEWAY': '1.2.3.5',
'ETH0_GATEWAY6': '',
'ETH0_IP': IP_BY_MACADDR,
'ETH0_IP6': '',
'ETH0_IP6_PREFIX_LENGTH': '',
'ETH0_IP6_ULA': '',
'ETH0_MAC': '02:00:0a:12:01:01',
'ETH0_MASK': '255.255.0.0',
'ETH0_MTU': '',
'ETH0_NETWORK': '10.18.0.0',
'ETH0_SEARCH_DOMAIN': '',
}
for nic in self.system_nics:
net = ds.OpenNebulaNetwork(context,
system_nics_by_mac={MACADDR: nic})
expected = {
'version': 2,
'ethernets': {
nic: {
'match': {'macaddress': MACADDR},
'addresses': [IP_BY_MACADDR + '/16'],
'gateway4': '1.2.3.5',
'nameservers': {
'addresses': ['1.2.3.6', '1.2.3.7', '1.2.3.8']}}}}
self.assertEqual(expected, net.gen_conf())
def test_eth0_override(self):
context = {
'DNS': '1.2.3.8',
'ETH0_IP': '1.2.3.4',
'ETH0_NETWORK': '1.2.3.0',
'ETH0_MASK': '255.255.0.0',
'ETH0_GATEWAY': '1.2.3.5',
'ETH0_DOMAIN': 'example.com',
'ETH0_DNS': '1.2.3.6 1.2.3.7'
}
net = ds.OpenNebulaNetwork(context,
system_nics_by_mac=self.system_nics)
self.assertEqual(
net.gen_conf(), u'''\
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.0.0
gateway 1.2.3.5
dns-search example.com
dns-nameservers 1.2.3.8 1.2.3.6 1.2.3.7
''')
def test_user_data(self):
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: USER_DATA})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('userdata' in results)
self.assertEqual(USER_DATA, results['userdata'])
def test_get_network(self):
"""
Verify get_network('device') correctly returns IPv4 network address.
"""
context = {'ETH0_NETWORK': '1.2.3.0'}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_network('eth0', MACADDR)
self.assertEqual('1.2.3.0', val)
def test_get_field(self):
"""
Verify get_field('device', 'name') returns *context* value.
"""
context = {'ETH9_DUMMY': 'DUMMY_VALUE'}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field('eth9', 'dummy')
self.assertEqual('DUMMY_VALUE', val)
def test_user_data_base64_encoding(self):
for k in ("USER_DATA", "USERDATA"):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: util.b64e(USER_DATA), "USERDATA_ENCODING": "base64"})
results = ds.read_context_disk_dir(my_d)
self.assertTrue("userdata" in results)
self.assertEqual(USER_DATA, results["userdata"])
def test_user_data_plain(self):
for k in ("USER_DATA", "USERDATA"):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: USER_DATA, "USERDATA_ENCODING": ""})
results = ds.read_context_disk_dir(my_d, mock.Mock())
self.assertTrue("userdata" in results)
self.assertEqual(USER_DATA, results["userdata"])
def test_user_data_plain(self):
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: USER_DATA, 'USERDATA_ENCODING': ''})
results = ds.read_context_disk_dir(my_d, mock.Mock())
self.assertTrue('userdata' in results)
self.assertEqual(USER_DATA, results['userdata'])
def test_user_data_plain(self):
for k in ("USER_DATA", "USERDATA"):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: USER_DATA, "USERDATA_ENCODING": ""})
results = ds.read_context_disk_dir(my_d)
self.assertTrue("userdata" in results)
self.assertEqual(USER_DATA, results["userdata"])
def test_get_mask(self):
"""
Verify get_mask('device') correctly returns IPv4 subnet mask.
"""
context = {'ETH0_MASK': '255.255.0.0'}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_mask('eth0')
self.assertEqual('255.255.0.0', val)
def test_get_ip6_prefix(self):
"""
Verify get_ip6_prefix('device') correctly returns IPv6 prefix.
"""
context = {'ETH0_IP6_PREFIX_LENGTH': IP6_PREFIX}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_ip6_prefix('eth0')
self.assertEqual(IP6_PREFIX, val)
def test_get_field(self):
"""
Verify get_field('device', 'name') returns *context* value.
"""
context = {"ETH9_DUMMY": "DUMMY_VALUE"}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field("eth9", "dummy")
self.assertEqual("DUMMY_VALUE", val)
def test_get_mask(self):
"""
Verify get_mask('device') correctly returns IPv4 subnet mask.
"""
context = {"ETH0_MASK": "255.255.0.0"}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_mask("eth0")
self.assertEqual("255.255.0.0", val)
def test_get_field_withdefaultvalue(self):
"""
Verify get_field('device', 'name', 'default value') returns *context*
value.
"""
context = {'ETH9_DUMMY': 'DUMMY_VALUE'}
net = ds.OpenNebulaNetwork(context)
val = net.get_field('eth9', 'dummy', 'DEFAULT_VALUE')
self.assertEqual('DUMMY_VALUE', val)
def test_user_data_base64_encoding(self):
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: util.b64e(USER_DATA),
'USERDATA_ENCODING': 'base64'})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('userdata' in results)
self.assertEqual(USER_DATA, results['userdata'])
def test_get_field_emptycontext(self):
"""
Verify get_field('device', 'name') returns None if context value is
empty string.
"""
context = {"ETH9_DUMMY": ""}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field("eth9", "dummy")
self.assertEqual(None, val)
def test_get_field_withdefaultvalue_emptycontext(self):
"""
Verify get_field('device', 'name', 'default value') returns *default*
value if context value is empty string.
"""
context = {"ETH9_DUMMY": ""}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field("eth9", "dummy", "DEFAULT_VALUE")
self.assertEqual("DEFAULT_VALUE", val)
def test_hostname(self):
for k in ("HOSTNAME", "PUBLIC_IP", "IP_PUBLIC", "ETH0_IP"):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: PUBLIC_IP})
results = ds.read_context_disk_dir(my_d)
self.assertTrue("metadata" in results)
self.assertTrue("local-hostname" in results["metadata"])
self.assertEqual(PUBLIC_IP, results["metadata"]["local-hostname"])
def test_get_field_emptycontext(self):
"""
Verify get_field('device', 'name') returns None if context value is
empty string.
"""
context = {'ETH9_DUMMY': ''}
net = ds.OpenNebulaNetwork(context)
val = net.get_field('eth9', 'dummy')
self.assertEqual(None, val)
def test_get_field_nonecontext(self):
"""
Verify get_field('device', 'name') returns None if context value is
None.
"""
context = {'ETH9_DUMMY': None}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field('eth9', 'dummy')
self.assertEqual(None, val)
def test_user_data_encoding_required_for_decode(self):
b64userdata = util.b64e(USER_DATA)
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: b64userdata})
results = ds.read_context_disk_dir(my_d, mock.Mock())
self.assertTrue('userdata' in results)
self.assertEqual(b64userdata, results['userdata'])
def test(self, interfaces_by_mac, physical_devs, expected_return):
distro = mock.Mock()
distro.networking.is_physical.side_effect = (
lambda devname: devname in physical_devs)
with mock.patch(
DS_PATH + ".net.get_interfaces_by_mac",
return_value=interfaces_by_mac,
):
assert expected_return == ds.get_physical_nics_by_mac(distro)
def test_get_field_withdefaultvalue_emptycontext(self):
"""
Verify get_field('device', 'name', 'default value') returns *default*
value if context value is empty string.
"""
context = {'ETH9_DUMMY': ''}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_field('eth9', 'dummy', 'DEFAULT_VALUE')
self.assertEqual('DEFAULT_VALUE', val)
def test_get_mask_emptystring(self):
"""
Verify get_mask('device') correctly returns IPv4 subnet mask.
It returns default value '255.255.255.0' if ETH0_MASK has empty string.
"""
context = {'ETH0_MASK': ''}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_mask('eth0')
self.assertEqual('255.255.255.0', val)
def test_get_gateway6(self):
"""
Verify get_gateway6('device') correctly returns IPv6 default gateway
address.
"""
context = {'ETH0_GATEWAY6': IP6_GW}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_gateway6('eth0')
self.assertEqual(IP6_GW, val)
def test_hostname(self):
for k in ('HOSTNAME', 'PUBLIC_IP', 'IP_PUBLIC', 'ETH0_IP'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: PUBLIC_IP})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('metadata' in results)
self.assertTrue('local-hostname' in results['metadata'])
self.assertEqual(PUBLIC_IP, results['metadata']['local-hostname'])
def test_user_data_base64_encoding(self):
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: b64encode(USER_DATA),
'USERDATA_ENCODING': 'base64'})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('userdata' in results)
self.assertEqual(USER_DATA, results['userdata'])
def test_user_data_encoding_required_for_decode(self):
b64userdata = b64encode(USER_DATA)
for k in ('USER_DATA', 'USERDATA'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: b64userdata})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('userdata' in results)
self.assertEqual(b64userdata, results['userdata'])
def test_get_gateway(self):
"""
Verify get_gateway('device') correctly returns IPv4 default gateway
address.
"""
context = {'ETH0_GATEWAY': '1.2.3.5'}
net = ds.OpenNebulaNetwork(context, mock.Mock())
val = net.get_gateway('eth0')
self.assertEqual('1.2.3.5', val)
def test_user_data_encoding_required_for_decode(self):
b64userdata = util.b64e(USER_DATA)
for k in ("USER_DATA", "USERDATA"):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: b64userdata})
results = ds.read_context_disk_dir(my_d)
self.assertTrue("userdata" in results)
self.assertEqual(b64userdata, results["userdata"])
def test_hostname(self, m_get_phys_by_mac):
for dev in ('eth0', 'ens3'):
m_get_phys_by_mac.return_value = {MACADDR: dev}
for k in ('HOSTNAME', 'PUBLIC_IP', 'IP_PUBLIC', 'ETH0_IP'):
my_d = os.path.join(self.tmp, k)
populate_context_dir(my_d, {k: PUBLIC_IP})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('metadata' in results)
self.assertTrue('local-hostname' in results['metadata'])
self.assertEqual(
PUBLIC_IP, results['metadata']['local-hostname'])
def test_find_candidates(self):
def my_devs_with(criteria):
return {"LABEL=CONTEXT": ["/dev/sdb"], "LABEL=CDROM": ["/dev/sr0"], "TYPE=iso9660": ["/dev/vdb"]}.get(
criteria, []
)
orig_find_devs_with = util.find_devs_with
try:
util.find_devs_with = my_devs_with
self.assertEqual(["/dev/sdb", "/dev/sr0", "/dev/vdb"], ds.find_candidate_devs())
finally:
util.find_devs_with = orig_find_devs_with
def test_ssh_key(self):
public_keys = ["first key", "second key"]
for c in range(4):
for k in ("SSH_KEY", "SSH_PUBLIC_KEY"):
my_d = os.path.join(self.tmp, "%s-%i" % (k, c))
populate_context_dir(my_d, {k: "\n".join(public_keys)})
results = ds.read_context_disk_dir(my_d)
self.assertTrue("metadata" in results)
self.assertTrue("public-keys" in results["metadata"])
self.assertEqual(public_keys, results["metadata"]["public-keys"])
public_keys.append(SSH_KEY % (c + 1,))
def test_ssh_key(self):
public_keys = ['first key', 'second key']
for c in range(4):
for k in ('SSH_KEY', 'SSH_PUBLIC_KEY'):
my_d = os.path.join(self.tmp, "%s-%i" % (k, c))
populate_context_dir(my_d, {k: '\n'.join(public_keys)})
results = ds.read_context_disk_dir(my_d)
self.assertTrue('metadata' in results)
self.assertTrue('public-keys' in results['metadata'])
self.assertEqual(public_keys,
results['metadata']['public-keys'])
public_keys.append(SSH_KEY % (c + 1,))
def test_network_interfaces(self):
populate_context_dir(self.seed_dir, {"ETH0_IP": "1.2.3.4"})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue("network-interfaces" in results)
def test_network_interfaces(self):
populate_context_dir(self.seed_dir, {'ETH0_IP': '1.2.3.4'})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
def test_no_seconds(self):
cfg = '\n'.join(["foo=bar", "SECONDS=2", "xx=foo"])
# we could test 'sleep 2', but that would make the test run slower.
ret = ds.parse_shell_config(cfg)
self.assertEqual(ret, {"foo": "bar", "xx": "foo"})
def test_seed_dir_empty1_context(self):
populate_dir(self.seed_dir, {"context.sh": ""})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertEqual(results["userdata"], None)
self.assertEqual(results["metadata"], {})
def test_seed_dir_empty1_context(self):
populate_dir(self.seed_dir, {'context.sh': ''})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertIsNone(results['userdata'])
self.assertEqual(results['metadata'], {})
def test_context_parser(self):
populate_context_dir(self.seed_dir, TEST_VARS)
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('metadata' in results)
self.assertEqual(TEST_VARS, results['metadata'])
def test_seed_dir_empty2_context(self):
populate_context_dir(self.seed_dir, {})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertEqual(results['userdata'], None)
self.assertEqual(results['metadata'], {})
def test_network_interfaces(self, m_get_phys_by_mac):
for dev in ('eth0', 'ens3'):
m_get_phys_by_mac.return_value = {MACADDR: dev}
# without ETH0_MAC
# for Older OpenNebula?
populate_context_dir(self.seed_dir, {'ETH0_IP': IP_BY_MACADDR})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP_BY_MACADDR + '/' + IP4_PREFIX in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP and ETH0_MAC
populate_context_dir(
self.seed_dir, {'ETH0_IP': IP_BY_MACADDR, 'ETH0_MAC': MACADDR})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP_BY_MACADDR + '/' + IP4_PREFIX in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP with empty string and ETH0_MAC
# in the case of using Virtual Network contains
# "AR = [ TYPE = ETHER ]"
populate_context_dir(
self.seed_dir, {'ETH0_IP': '', 'ETH0_MAC': MACADDR})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP_BY_MACADDR + '/' + IP4_PREFIX in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_MASK
populate_context_dir(
self.seed_dir, {
'ETH0_IP': IP_BY_MACADDR,
'ETH0_MAC': MACADDR,
'ETH0_MASK': '255.255.0.0'
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP_BY_MACADDR + '/16' in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_MASK with empty string
populate_context_dir(
self.seed_dir, {
'ETH0_IP': IP_BY_MACADDR,
'ETH0_MAC': MACADDR,
'ETH0_MASK': ''
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP_BY_MACADDR + '/' + IP4_PREFIX in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP6
populate_context_dir(
self.seed_dir, {
'ETH0_IP6': IP6_GLOBAL,
'ETH0_MAC': MACADDR,
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP6_GLOBAL + '/64' in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP6_ULA
populate_context_dir(
self.seed_dir, {
'ETH0_IP6_ULA': IP6_ULA,
'ETH0_MAC': MACADDR,
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP6_ULA + '/64' in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP6 and ETH0_IP6_PREFIX_LENGTH
populate_context_dir(
self.seed_dir, {
'ETH0_IP6': IP6_GLOBAL,
'ETH0_IP6_PREFIX_LENGTH': IP6_PREFIX,
'ETH0_MAC': MACADDR,
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP6_GLOBAL + '/' + IP6_PREFIX in
results['network-interfaces']['ethernets'][dev]['addresses'])
# ETH0_IP6 and ETH0_IP6_PREFIX_LENGTH with empty string
populate_context_dir(
self.seed_dir, {
'ETH0_IP6': IP6_GLOBAL,
'ETH0_IP6_PREFIX_LENGTH': '',
'ETH0_MAC': MACADDR,
})
results = ds.read_context_disk_dir(self.seed_dir)
self.assertTrue('network-interfaces' in results)
self.assertTrue(
IP6_GLOBAL + '/64' in
results['network-interfaces']['ethernets'][dev]['addresses'])
