dnsmasq_pid_file='/run/networkd-ci/test-test-dnsmasq.pid'
dnsmasq_log_file='/run/networkd-ci/test-dnsmasq-log-file'
+wait_online_bin='/usr/lib/systemd/systemd-networkd-wait-online'
+
def is_module_available(module_name):
lsmod_output = subprocess.check_output('lsmod', universal_newlines=True)
module_re = re.compile(r'^{0}\b'.format(re.escape(module_name)), re.MULTILINE)
return f
def setUpModule():
-
os.makedirs(network_unit_file_path, exist_ok=True)
os.makedirs(networkd_ci_path, exist_ok=True)
subprocess.call(['ip', 'link', 'del', 'dev', link])
time.sleep(1)
+ def l2tp_tunnel_remove(self, tunnel_ids):
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'tunnel']).rstrip().decode('utf-8')
+ for tid in tunnel_ids:
+ words='Tunnel ' + tid + ', encap'
+ if words in output:
+ subprocess.call(['ip', 'l2tp', 'del', 'tunnel', 'tid', tid])
+ time.sleep(1)
+
def read_ipv6_sysctl_attr(self, link, attribute):
with open(os.path.join(os.path.join(network_sysctl_ipv6_path, link), attribute)) as f:
return f.readline().strip()
if os.path.exists(dnsmasq_log_file):
os.remove(dnsmasq_log_file)
- def start_networkd(self, remove_state_files=True):
+ def start_networkd(self, sleep_sec=5, remove_state_files=True):
if (remove_state_files and
os.path.exists(os.path.join(networkd_runtime_directory, 'state'))):
subprocess.check_call('systemctl stop systemd-networkd', shell=True)
subprocess.check_call('systemctl start systemd-networkd', shell=True)
else:
subprocess.check_call('systemctl restart systemd-networkd', shell=True)
- time.sleep(5)
+ if sleep_sec > 0:
+ time.sleep(sleep_sec)
+
+ def wait_online(self, links_with_operstate, timeout='20s', bool_any=False):
+ args = [wait_online_bin, f'--timeout={timeout}'] + [f'--interface={link}' for link in links_with_operstate]
+ if bool_any:
+ args += ['--any']
+ subprocess.check_call(args)
class NetworkdNetDevTests(unittest.TestCase, Utilities):
'bridge99',
'dropin-test',
'dummy98',
- 'erspan-test',
+ 'erspan98',
+ 'erspan99',
'geneve99',
+ 'gretap96',
+ 'gretap98',
'gretap99',
+ 'gretun96',
+ 'gretun97',
+ 'gretun98',
'gretun99',
+ 'ip6gretap98',
'ip6gretap99',
+ 'ip6gretun97',
+ 'ip6gretun98',
+ 'ip6gretun99',
+ 'ip6tnl97',
+ 'ip6tnl98',
'ip6tnl99',
+ 'ipiptun96',
+ 'ipiptun97',
+ 'ipiptun98',
'ipiptun99',
'ipvlan99',
'isataptun99',
'macvlan99',
'macvtap99',
+ 'sittun96',
+ 'sittun97',
+ 'sittun98',
'sittun99',
'tap99',
'test1',
'veth99',
'vlan99',
'vrf99',
+ 'vti6tun97',
+ 'vti6tun98',
'vti6tun99',
+ 'vtitun97',
+ 'vtitun98',
'vtitun99',
'vxlan99',
'wg98',
units = [
'10-dropin-test.netdev',
'11-dummy.netdev',
+ '11-dummy.network',
'12-dummy.netdev',
+ '15-name-conflict-test.netdev',
'21-macvlan.netdev',
'21-macvtap.netdev',
+ '21-vlan-test1.network',
'21-vlan.netdev',
'21-vlan.network',
'25-6rd-tunnel.netdev',
'25-bond.netdev',
'25-bond-balanced-tlb.netdev',
'25-bridge.netdev',
+ '25-bridge.network',
+ '25-erspan-tunnel-local-any.netdev',
'25-erspan-tunnel.netdev',
+ '25-fou-gretap.netdev',
+ '25-fou-gre.netdev',
+ '25-fou-ipip.netdev',
+ '25-fou-ipproto-gre.netdev',
+ '25-fou-ipproto-ipip.netdev',
+ '25-fou-sit.netdev',
'25-geneve.netdev',
+ '25-gretap-tunnel-local-any.netdev',
'25-gretap-tunnel.netdev',
+ '25-gre-tunnel-local-any.netdev',
+ '25-gre-tunnel-remote-any.netdev',
'25-gre-tunnel.netdev',
+ '25-ip6gretap-tunnel-local-any.netdev',
+ '25-ip6gretap-tunnel.netdev',
+ '25-ip6gre-tunnel-local-any.netdev',
+ '25-ip6gre-tunnel-remote-any.netdev',
'25-ip6gre-tunnel.netdev',
+ '25-ip6tnl-tunnel-remote-any.netdev',
+ '25-ip6tnl-tunnel-local-any.netdev',
'25-ip6tnl-tunnel.netdev',
'25-ipip-tunnel-independent.netdev',
+ '25-ipip-tunnel-local-any.netdev',
+ '25-ipip-tunnel-remote-any.netdev',
'25-ipip-tunnel.netdev',
'25-ipvlan.netdev',
'25-isatap-tunnel.netdev',
+ '25-macsec.key',
+ '25-macsec.netdev',
+ '25-macsec.network',
+ '25-sit-tunnel-local-any.netdev',
+ '25-sit-tunnel-remote-any.netdev',
'25-sit-tunnel.netdev',
'25-tap.netdev',
'25-tun.netdev',
'25-vcan.netdev',
'25-veth.netdev',
'25-vrf.netdev',
+ '25-vti6-tunnel-local-any.netdev',
+ '25-vti6-tunnel-remote-any.netdev',
'25-vti6-tunnel.netdev',
+ '25-vti-tunnel-local-any.netdev',
+ '25-vti-tunnel-remote-any.netdev',
'25-vti-tunnel.netdev',
'25-vxlan.netdev',
'25-wireguard-23-peers.netdev',
'25-wireguard-23-peers.network',
+ '25-wireguard-preshared-key.txt',
+ '25-wireguard-private-key.txt',
'25-wireguard.netdev',
+ '25-wireguard.network',
'6rd.network',
+ 'erspan.network',
'gre.network',
'gretap.network',
'gretun.network',
'ip6gretap.network',
+ 'ip6gretun.network',
'ip6tnl.network',
'ipip.network',
'ipvlan.network',
'isatap.network',
+ 'macsec.network',
'macvlan.network',
'macvtap.network',
'sit.network',
self.remove_unit_from_networkd_path(self.units)
def test_dropin(self):
- self.copy_unit_to_networkd_unit_path('10-dropin-test.netdev')
+ self.copy_unit_to_networkd_unit_path('10-dropin-test.netdev', '15-name-conflict-test.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dropin-test'))
+ # This also tests NetDev.Name= conflict and basic networkctl functionalities
+
output = subprocess.check_output(['ip', 'link', 'show', 'dropin-test']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, '00:50:56:c0:00:28')
else:
print('ethtool does not support driver field at least for dummy interfaces, skipping test for Driver field of networkctl.')
+ def test_wait_online_any(self):
+ self.copy_unit_to_networkd_unit_path('25-bridge.netdev', '25-bridge.network', '11-dummy.netdev', '11-dummy.network')
+ self.start_networkd(0)
+
+ self.wait_online(['bridge99', 'test1:degraded'], bool_any=True)
+ self.assertTrue(self.link_exits('bridge99'))
+ self.assertTrue(self.link_exits('test1'))
+
+ output = subprocess.check_output(['networkctl', 'status', 'bridge99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'State: (?:off|no-carrier) \(configuring\)')
+
+ output = subprocess.check_output(['networkctl', 'status', 'test1']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'State: degraded \(configured\)')
+
def test_bridge(self):
self.copy_unit_to_networkd_unit_path('25-bridge.netdev')
self.start_networkd()
self.assertEqual('1', self.read_link_attr('bond99', 'bonding', 'tlb_dynamic_lb'))
def test_vlan(self):
- self.copy_unit_to_networkd_unit_path('21-vlan.netdev', '11-dummy.netdev', '21-vlan.network')
+ self.copy_unit_to_networkd_unit_path('21-vlan.netdev', '11-dummy.netdev',
+ '21-vlan.network', '21-vlan-test1.network')
self.start_networkd()
self.assertTrue(self.link_exits('test1'))
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'test1']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2004 ')
+ self.assertRegex(output, ' mtu 2004 ')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vlan99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
- self.assertTrue(output, 'REORDER_HDR')
- self.assertTrue(output, 'LOOSE_BINDING')
- self.assertTrue(output, 'GVRP')
- self.assertTrue(output, 'MVRP')
- self.assertTrue(output, ' id 99 ')
+ self.assertRegex(output, ' mtu 2000 ')
+ self.assertRegex(output, 'REORDER_HDR')
+ self.assertRegex(output, 'LOOSE_BINDING')
+ self.assertRegex(output, 'GVRP')
+ self.assertRegex(output, 'MVRP')
+ self.assertRegex(output, ' id 99 ')
+
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'test1']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'inet 192.168.24.5/24 brd 192.168.24.255 scope global test1')
+ self.assertRegex(output, 'inet 192.168.25.5/24 brd 192.168.25.255 scope global test1')
+
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'vlan99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'inet 192.168.23.5/24 brd 192.168.23.255 scope global vlan99')
def test_macvtap(self):
self.copy_unit_to_networkd_unit_path('21-macvtap.netdev', '11-dummy.netdev', 'macvtap.network')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'test1']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
+ self.assertRegex(output, ' mtu 2000 ')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'macvlan99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, ' mtu 2000 ')
+ self.assertRegex(output, ' mtu 2000 ')
@expectedFailureIfModuleIsNotAvailable('ipvlan')
def test_ipvlan(self):
@expectedFailureIfModuleIsNotAvailable('wireguard')
def test_wireguard(self):
- self.copy_unit_to_networkd_unit_path('25-wireguard.netdev')
- self.start_networkd()
+ self.copy_unit_to_networkd_unit_path('25-wireguard.netdev', '25-wireguard.network',
+ '25-wireguard-23-peers.netdev', '25-wireguard-23-peers.network',
+ '25-wireguard-preshared-key.txt', '25-wireguard-private-key.txt')
+ self.start_networkd(0)
+ self.wait_online(['wg99:carrier', 'wg98:routable'])
+
+ self.assertTrue(self.link_exits('wg99'))
+ self.assertTrue(self.link_exits('wg98'))
if shutil.which('wg'):
subprocess.call('wg')
+
output = subprocess.check_output(['wg', 'show', 'wg99', 'listen-port']).rstrip().decode('utf-8')
- self.assertTrue(output, '51820')
+ self.assertRegex(output, '51820')
output = subprocess.check_output(['wg', 'show', 'wg99', 'fwmark']).rstrip().decode('utf-8')
- self.assertTrue(output, '0x4d2')
+ self.assertRegex(output, '0x4d2')
output = subprocess.check_output(['wg', 'show', 'wg99', 'allowed-ips']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.26.0/24 fd31:bf08:57cb::/48')
+ self.assertRegex(output, 'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc=\tfdbc:bae2:7871:e1fe:793:8636::/96 fdbc:bae2:7871:500:e1fe:793:8636:dad1/128')
output = subprocess.check_output(['wg', 'show', 'wg99', 'persistent-keepalive']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t20')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t20')
output = subprocess.check_output(['wg', 'show', 'wg99', 'endpoints']).rstrip().decode('utf-8')
- self.assertTrue(output, 'RDf+LSpeEre7YEIKaxg+wbpsNV7du+ktR99uBEtIiCA=\t192.168.27.3:51820')
-
- self.assertTrue(self.link_exits('wg99'))
-
- @expectedFailureIfModuleIsNotAvailable('wireguard')
- def test_wireguard_23_peers(self):
- self.copy_unit_to_networkd_unit_path('25-wireguard-23-peers.netdev', '25-wireguard-23-peers.network')
- self.start_networkd()
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA=\t192.168.27.3:51820')
+ output = subprocess.check_output(['wg', 'show', 'wg99', 'private-key']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'EEGlnEPYJV//kbvvIqxKkQwOiS\+UENyPncC4bF46ong=')
+ output = subprocess.check_output(['wg', 'show', 'wg99', 'preshared-keys']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'RDf\+LSpeEre7YEIKaxg\+wbpsNV7du\+ktR99uBEtIiCA= IIWIV17wutHv7t4cR6pOT91z6NSz/T8Arh0yaywhw3M=')
+ self.assertRegex(output, 'lsDtM3AbjxNlauRKzHEPfgS1Zp7cp/VX5Use/P4PQSc= cPLOy1YUrEI0EMMIycPJmOo0aTu3RZnw8bL5meVD6m0=')
- if shutil.which('wg'):
- subprocess.call('wg')
-
- self.assertTrue(self.link_exits('wg98'))
+ output = subprocess.check_output(['wg', 'show', 'wg98', 'private-key']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'CJQUtcS9emY2fLYqDlpSZiE/QJyHkPWr\+WHtZLZ90FU=')
def test_geneve(self):
self.copy_unit_to_networkd_unit_path('25-geneve.netdev')
output = subprocess.check_output(['ip', '-d', 'link', 'show', 'geneve99']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, '192.168.22.1')
- self.assertTrue(output, '6082')
- self.assertTrue(output, 'udpcsum')
- self.assertTrue(output, 'udp6zerocsumrx')
+ self.assertRegex(output, '192.168.22.1')
+ self.assertRegex(output, '6082')
+ self.assertRegex(output, 'udpcsum')
+ self.assertRegex(output, 'udp6zerocsumrx')
def test_ipip_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ipip-tunnel.netdev', 'ipip.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ipip-tunnel.netdev', 'ipip.network',
+ '25-ipip-tunnel-local-any.netdev', '25-ipip-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('ipiptun99'))
+ self.assertTrue(self.link_exits('ipiptun98'))
+ self.assertTrue(self.link_exits('ipiptun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local 192.168.223.238 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ipip (?:ipip |)remote 192.169.224.239 local any dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ipip (?:ipip |)remote any local 192.168.223.238 dev dummy98')
def test_gre_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gre-tunnel.netdev', 'gretun.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gre-tunnel.netdev', 'gretun.network',
+ '25-gre-tunnel-local-any.netdev', '25-gre-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('gretun99'))
+ self.assertTrue(self.link_exits('gretun98'))
+ self.assertTrue(self.link_exits('gretun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'gre remote 10.65.223.239 local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 1.2.3.103')
+ self.assertRegex(output, 'okey 1.2.4.103')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'gre remote 10.65.223.239 local any dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.104')
+ self.assertRegex(output, 'okey 0.0.0.104')
+ self.assertNotRegex(output, 'iseq')
+ self.assertNotRegex(output, 'oseq')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'gre remote any local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.105')
+ self.assertRegex(output, 'okey 0.0.0.105')
+ self.assertNotRegex(output, 'iseq')
+ self.assertNotRegex(output, 'oseq')
+
+ def test_ip6gre_tunnel(self):
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6gre-tunnel.netdev', 'ip6gretun.network',
+ '25-ip6gre-tunnel-local-any.netdev', '25-ip6gre-tunnel-remote-any.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('dummy98'))
+ self.assertTrue(self.link_exits('ip6gretun99'))
+ self.assertTrue(self.link_exits('ip6gretun98'))
+ self.assertTrue(self.link_exits('ip6gretun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6gre remote 2001:473:fece:cafe::5179 local any dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6gre remote any local 2a00:ffde:4567:edde::4987 dev dummy98')
def test_gretap_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gretap-tunnel.netdev', 'gretap.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-gretap-tunnel.netdev', 'gretap.network',
+ '25-gretap-tunnel-local-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('gretap99'))
+ self.assertTrue(self.link_exits('gretap98'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'gretap remote 10.65.223.239 local 10.65.223.238 dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.106')
+ self.assertRegex(output, 'okey 0.0.0.106')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'gretap remote 10.65.223.239 local any dev dummy98')
+ self.assertRegex(output, 'ikey 0.0.0.107')
+ self.assertRegex(output, 'okey 0.0.0.107')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
def test_ip6gretap_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6gre-tunnel.netdev', 'ip6gretap.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6gretap-tunnel.netdev', 'ip6gretap.network',
+ '25-ip6gretap-tunnel-local-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('ip6gretap99'))
+ self.assertTrue(self.link_exits('ip6gretap98'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretap99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6gretap98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6gretap remote 2001:473:fece:cafe::5179 local any dev dummy98')
def test_vti_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti-tunnel.netdev', 'vti.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti-tunnel.netdev', 'vti.network',
+ '25-vti-tunnel-local-any.netdev', '25-vti-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('vtitun99'))
+ self.assertTrue(self.link_exits('vtitun98'))
+ self.assertTrue(self.link_exits('vtitun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vtitun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti remote 10.65.223.239 local 10.65.223.238 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vtitun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti remote 10.65.223.239 local any dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vtitun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti remote any local 10.65.223.238 dev dummy98')
def test_vti6_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti6-tunnel.netdev', 'vti6.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-vti6-tunnel.netdev', 'vti6.network',
+ '25-vti6-tunnel-local-any.netdev', '25-vti6-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('vti6tun99'))
+ self.assertTrue(self.link_exits('vti6tun98'))
+ self.assertTrue(self.link_exits('vti6tun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vti6tun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vti6tun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'vti6tun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'vti6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
def test_ip6tnl_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6tnl-tunnel.netdev', 'ip6tnl.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-ip6tnl-tunnel.netdev', 'ip6tnl.network',
+ '25-ip6tnl-tunnel-local-any.netdev', '25-ip6tnl-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('ip6tnl99'))
+ self.assertTrue(self.link_exits('ip6tnl98'))
+ self.assertTrue(self.link_exits('ip6tnl97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6tnl99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local 2a00:ffde:4567:edde::4987 dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6tnl98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6tnl ip6ip6 remote 2001:473:fece:cafe::5179 local (?:any|::) dev dummy98')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ip6tnl97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'ip6tnl ip6ip6 remote (?:any|::) local 2a00:ffde:4567:edde::4987 dev dummy98')
def test_sit_tunnel(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-sit-tunnel.netdev', 'sit.network')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-sit-tunnel.netdev', 'sit.network',
+ '25-sit-tunnel-local-any.netdev',
+ '25-sit-tunnel-remote-any.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('sittun99'))
+ self.assertTrue(self.link_exits('sittun98'))
+ self.assertTrue(self.link_exits('sittun97'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local 10.65.223.238 dev dummy98")
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "sit (?:ip6ip |)remote 10.65.223.239 local any dev dummy98")
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun97']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "sit (?:ip6ip |)remote any local 10.65.223.238 dev dummy98")
def test_isatap_tunnel(self):
self.copy_unit_to_networkd_unit_path('12-dummy.netdev', '25-isatap-tunnel.netdev', 'isatap.network')
self.assertTrue(self.link_exits('dummy98'))
self.assertTrue(self.link_exits('sittun99'))
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, '6rd-prefix 2602::/24')
+
@expectedFailureIfERSPANModuleIsNotAvailable()
def test_erspan_tunnel(self):
- self.copy_unit_to_networkd_unit_path('25-erspan-tunnel.netdev')
+ self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'erspan.network',
+ '25-erspan-tunnel.netdev', '25-erspan-tunnel-local-any.netdev')
self.start_networkd()
- self.assertTrue(self.link_exits('erspan-test'))
+ self.assertTrue(self.link_exits('dummy98'))
+ self.assertTrue(self.link_exits('erspan99'))
+ self.assertTrue(self.link_exits('erspan98'))
- output = subprocess.check_output(['ip', '-d', 'link', 'show', 'erspan-test']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'erspan99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'erspan remote 172.16.1.100 local 172.16.1.200')
+ self.assertRegex(output, 'ikey 0.0.0.101')
+ self.assertRegex(output, 'okey 0.0.0.101')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'erspan98']).rstrip().decode('utf-8')
print(output)
- self.assertTrue(output, '172.16.1.200')
- self.assertTrue(output, '172.16.1.100')
- self.assertTrue(output, '101')
+ self.assertRegex(output, 'erspan remote 172.16.1.100 local any')
+ self.assertRegex(output, '102')
+ self.assertRegex(output, 'ikey 0.0.0.102')
+ self.assertRegex(output, 'okey 0.0.0.102')
+ self.assertRegex(output, 'iseq')
+ self.assertRegex(output, 'oseq')
def test_tunnel_independent(self):
self.copy_unit_to_networkd_unit_path('25-ipip-tunnel-independent.netdev')
self.assertTrue(self.link_exits('ipiptun99'))
+ @expectedFailureIfModuleIsNotAvailable('fou')
+ def test_fou(self):
+ # The following redundant check is necessary for CentOS CI.
+ # Maybe, error handling in lookup_id() in sd-netlink/generic-netlink.c needs to be updated.
+ self.assertTrue(is_module_available('fou'))
+
+ self.copy_unit_to_networkd_unit_path('25-fou-ipproto-ipip.netdev', '25-fou-ipproto-gre.netdev',
+ '25-fou-ipip.netdev', '25-fou-sit.netdev',
+ '25-fou-gre.netdev', '25-fou-gretap.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('ipiptun96'))
+ self.assertTrue(self.link_exits('sittun96'))
+ self.assertTrue(self.link_exits('gretun96'))
+ self.assertTrue(self.link_exits('gretap96'))
+
+ output = subprocess.check_output(['ip', 'fou', 'show']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'port 55555 ipproto 4')
+ self.assertRegex(output, 'port 55556 ipproto 47')
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'ipiptun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'sittun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55555')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretun96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport 1001 encap-dport 55556')
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'gretap96']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encap fou encap-sport auto encap-dport 55556')
+
+ subprocess.call(['ip', 'fou', 'del', 'port', '55555'])
+ subprocess.call(['ip', 'fou', 'del', 'port', '55556'])
+
def test_vxlan(self):
- self.copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network','11-dummy.netdev')
+ self.copy_unit_to_networkd_unit_path('25-vxlan.netdev', 'vxlan.network', '11-dummy.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('vxlan99'))
self.assertRegex(output, 'remcsumrx')
self.assertRegex(output, 'gbp')
+ def test_macsec(self):
+ self.copy_unit_to_networkd_unit_path('25-macsec.netdev', '25-macsec.network', '25-macsec.key',
+ 'macsec.network', '12-dummy.netdev')
+ self.start_networkd(0)
+
+ self.wait_online(['dummy98:degraded', 'macsec99:routable'])
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'macsec99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'macsec99@dummy98')
+ self.assertRegex(output, 'macsec sci [0-9a-f]*000b')
+ self.assertRegex(output, 'encrypt on')
+
+ output = subprocess.check_output(['ip', 'macsec', 'show', 'macsec99']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'encrypt on')
+ self.assertRegex(output, 'TXSC: [0-9a-f]*000b on SA 1')
+ self.assertRegex(output, '0: PN [0-9]*, state on, key 01000000000000000000000000000000')
+ self.assertRegex(output, '1: PN [0-9]*, state on, key 02030000000000000000000000000000')
+ self.assertRegex(output, 'RXSC: c619528fe6a00100, state on')
+ self.assertRegex(output, '0: PN [0-9]*, state on, key 02030405000000000000000000000000')
+ self.assertRegex(output, '1: PN [0-9]*, state on, key 02030405060000000000000000000000')
+ self.assertRegex(output, '2: PN [0-9]*, state off, key 02030405060700000000000000000000')
+ self.assertRegex(output, '3: PN [0-9]*, state off, key 02030405060708000000000000000000')
+ self.assertNotRegex(output, 'key 02030405067080900000000000000000')
+ self.assertRegex(output, 'RXSC: 8c16456c83a90002, state on')
+ self.assertRegex(output, '0: PN [0-9]*, state off, key 02030400000000000000000000000000')
+
+
+class NetworkdL2TPTests(unittest.TestCase, Utilities):
+
+ links =[
+ 'l2tp-ses1',
+ 'l2tp-ses2',
+ 'l2tp-ses3',
+ 'l2tp-ses4',
+ 'test1']
+
+ units = [
+ '11-dummy.netdev',
+ '25-l2tp-dummy.network',
+ '25-l2tp-ip.netdev',
+ '25-l2tp-udp.netdev']
+
+ l2tp_tunnel_ids = [ '10' ]
+
+ def setUp(self):
+ self.l2tp_tunnel_remove(self.l2tp_tunnel_ids)
+ self.link_remove(self.links)
+
+ def tearDown(self):
+ self.l2tp_tunnel_remove(self.l2tp_tunnel_ids)
+ self.link_remove(self.links)
+ self.remove_unit_from_networkd_path(self.units)
+
+ @expectedFailureIfModuleIsNotAvailable('l2tp_eth')
+ def test_l2tp_udp(self):
+ self.copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-udp.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('test1'))
+ self.assertTrue(self.link_exits('l2tp-ses1'))
+ self.assertTrue(self.link_exits('l2tp-ses2'))
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'tunnel', 'tunnel_id', '10']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Tunnel 10, encap UDP")
+ self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
+ self.assertRegex(output, "Peer tunnel 11")
+ self.assertRegex(output, "UDP source / dest ports: 3000/4000")
+ self.assertRegex(output, "UDP checksum: enabled")
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'session', 'tid', '10', 'session_id', '15']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Session 15 in tunnel 10")
+ self.assertRegex(output, "Peer session 16, tunnel 11")
+ self.assertRegex(output, "interface name: l2tp-ses1")
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'session', 'tid', '10', 'session_id', '17']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Session 17 in tunnel 10")
+ self.assertRegex(output, "Peer session 18, tunnel 11")
+ self.assertRegex(output, "interface name: l2tp-ses2")
+
+ @expectedFailureIfModuleIsNotAvailable('l2tp_ip')
+ def test_l2tp_ip(self):
+ self.copy_unit_to_networkd_unit_path('11-dummy.netdev', '25-l2tp-dummy.network', '25-l2tp-ip.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('test1'))
+ self.assertTrue(self.link_exits('l2tp-ses3'))
+ self.assertTrue(self.link_exits('l2tp-ses4'))
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'tunnel', 'tunnel_id', '10']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Tunnel 10, encap IP")
+ self.assertRegex(output, "From 192.168.30.100 to 192.168.30.101")
+ self.assertRegex(output, "Peer tunnel 12")
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'session', 'tid', '10', 'session_id', '25']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Session 25 in tunnel 10")
+ self.assertRegex(output, "Peer session 26, tunnel 12")
+ self.assertRegex(output, "interface name: l2tp-ses3")
+
+ output = subprocess.check_output(['ip', 'l2tp', 'show', 'session', 'tid', '10', 'session_id', '27']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, "Session 27 in tunnel 10")
+ self.assertRegex(output, "Peer session 28, tunnel 12")
+ self.assertRegex(output, "interface name: l2tp-ses4")
+
class NetworkdNetWorkTests(unittest.TestCase, Utilities):
links = [
'bond199',
'11-dummy.netdev',
'12-dummy.netdev',
'23-active-slave.network',
- '23-bond199.network',
- '23-primary-slave.network',
- '23-test1-bond199.network',
'25-address-link-section.network',
- '25-address-section-miscellaneous.network',
- '25-address-section.network',
+ '25-address-preferred-lifetime-zero-ipv6.network',
+ '25-address-static.network',
'25-bind-carrier.network',
'25-bond-active-backup-slave.netdev',
'25-fibrule-invert.network',
'25-link-local-addressing-no.network',
'25-link-local-addressing-yes.network',
'25-link-section-unmanaged.network',
- '25-route-gateway.network',
- '25-route-gateway-on-link.network',
'25-route-ipv6-src.network',
- '25-route-reverse-order.network',
- '25-route-section.network',
- '25-route-tcp-window-settings.network',
- '25-route-type.network',
+ '25-route-static.network',
'25-sysctl-disable-ipv6.network',
'25-sysctl.network',
'configure-without-carrier.network',
'routing-policy-rule-dummy98.network',
- 'routing-policy-rule-test1.network',
- 'test-static.network']
+ 'routing-policy-rule-test1.network']
def setUp(self):
self.link_remove(self.links)
self.link_remove(self.links)
self.remove_unit_from_networkd_path(self.units)
- def test_static_address(self):
- self.copy_unit_to_networkd_unit_path('12-dummy.netdev', 'test-static.network')
- self.start_networkd()
+ def test_address_static(self):
+ self.copy_unit_to_networkd_unit_path('25-address-static.network', '12-dummy.netdev')
+ self.start_networkd(0)
- self.assertTrue(self.link_exits('dummy98'))
+ self.wait_online(['dummy98:routable'])
- output = subprocess.check_output(['networkctl', 'status', 'dummy98']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'dummy98']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, '192.168.0.15')
- self.assertRegex(output, '192.168.0.1')
- self.assertRegex(output, 'routable')
+ self.assertRegex(output, 'inet 10.1.2.3/16 brd 10.1.255.255 scope global dummy98')
+ self.assertRegex(output, 'inet 10.1.2.4/16 brd 10.1.255.255 scope global secondary dummy98')
+ self.assertRegex(output, 'inet 10.2.2.4/16 brd 10.2.255.255 scope global dummy98')
- def test_configure_without_carrier(self):
- self.copy_unit_to_networkd_unit_path('configure-without-carrier.network', '11-dummy.netdev')
- self.start_networkd()
+ # invalid sections
+ self.assertNotRegex(output, '10.10.0.1/16')
+ self.assertNotRegex(output, '10.10.0.2/16')
- self.assertTrue(self.link_exits('test1'))
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'dummy98', 'label', '32']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 10.3.2.3/16 brd 10.3.255.255 scope global 32')
- output = subprocess.check_output(['networkctl', 'status', 'test1']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'dummy98', 'label', '33']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 10.4.2.3 peer 10.4.2.4/16 scope global 33')
+
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'dummy98', 'label', '34']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 192.168.[0-9]*.1/24 brd 192.168.[0-9]*.255 scope global 34')
+
+ output = subprocess.check_output(['ip', '-4', 'address', 'show', 'dev', 'dummy98', 'label', '35']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'inet 172.[0-9]*.0.1/16 brd 172.[0-9]*.255.255 scope global 35')
+
+ output = subprocess.check_output(['ip', '-6', 'address', 'show', 'dev', 'dummy98']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, '192.168.0.15')
- self.assertRegex(output, '192.168.0.1')
- self.assertRegex(output, 'routable')
+ self.assertRegex(output, 'inet6 2001:db8:0:f101::15/64 scope global')
+ self.assertRegex(output, 'inet6 2001:db8:0:f101::16/64 scope global')
+ self.assertRegex(output, 'inet6 2001:db8:0:f102::15/64 scope global')
+ self.assertRegex(output, 'inet6 2001:db8:0:f102::16/64 scope global')
+ self.assertRegex(output, 'inet6 2001:db8:0:f103::20 peer 2001:db8:0:f103::10/128 scope global')
+ self.assertRegex(output, 'inet6 fd[0-9a-f:]*1/64 scope global')
- def test_bond_active_slave(self):
- self.copy_unit_to_networkd_unit_path('23-active-slave.network', '23-bond199.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
+ def test_address_preferred_lifetime_zero_ipv6(self):
+ self.copy_unit_to_networkd_unit_path('25-address-preferred-lifetime-zero-ipv6.network', '12-dummy.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('dummy98'))
- self.assertTrue(self.link_exits('bond199'))
- output = subprocess.check_output(['ip', '-d', 'link', 'show', 'bond199']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['networkctl', 'status', 'dummy98']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'active_slave dummy98')
+ self.assertRegex(output, 'State: routable \(configuring\)')
- def test_bond_primary_slave(self):
- self.copy_unit_to_networkd_unit_path('23-primary-slave.network', '23-test1-bond199.network', '25-bond-active-backup-slave.netdev', '11-dummy.netdev')
+ output = subprocess.check_output(['ip', 'address', 'show', 'dummy98']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope link deprecated dummy98')
+ self.assertRegex(output, 'inet6 2001:db8:0:f101::1/64 scope global')
+
+ def test_configure_without_carrier(self):
+ self.copy_unit_to_networkd_unit_path('configure-without-carrier.network', '11-dummy.netdev')
self.start_networkd()
self.assertTrue(self.link_exits('test1'))
- self.assertTrue(self.link_exits('bond199'))
- output = subprocess.check_output(['ip', '-d', 'link', 'show', 'bond199']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['networkctl', 'status', 'test1']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'primary test1')
+ self.assertRegex(output, '192.168.0.15')
+ self.assertRegex(output, '192.168.0.1')
+ self.assertRegex(output, 'routable')
def test_routing_policy_rule(self):
self.copy_unit_to_networkd_unit_path('routing-policy-rule-test1.network', '11-dummy.netdev')
for trial in range(3):
# Remove state files only first time
- self.start_networkd(trial == 0)
+ self.start_networkd(remove_state_files=(trial == 0))
self.assertTrue(self.link_exits('test1'))
self.assertTrue(self.link_exits('dummy98'))
subprocess.call(['ip', 'rule', 'del', 'table', '7'])
- def test_address_peer(self):
- self.copy_unit_to_networkd_unit_path('25-address-section.network', '12-dummy.netdev')
- self.start_networkd()
+ def test_route_static(self):
+ self.copy_unit_to_networkd_unit_path('25-route-static.network', '12-dummy.netdev')
+ self.start_networkd(0)
- self.assertTrue(self.link_exits('dummy98'))
+ self.wait_online(['dummy98:routable'])
- output = subprocess.check_output(['ip', 'address', 'show', 'dummy98']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', '-6', 'route', 'show', 'dev', 'dummy98']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'inet 10.2.3.4 peer 10.2.3.5/16 scope global 32')
- self.assertRegex(output, 'inet 10.6.7.8/16 brd 10.6.255.255 scope global 33')
- self.assertRegex(output, 'inet6 2001:db8::20 peer 2001:db8::10/128 scope global')
+ self.assertRegex(output, '2001:1234:5:8fff:ff:ff:ff:ff proto static')
+ self.assertRegex(output, '2001:1234:5:8f63::1 proto kernel')
- output = subprocess.check_output(['networkctl', 'status', 'dummy98']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, 'State: routable \(configured\)')
+ output = subprocess.check_output(['ip', '-6', 'route', 'show', 'dev', 'dummy98', 'default']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'default via 2001:1234:5:8fff:ff:ff:ff:ff proto static metric 1024 pref medium')
- def test_address_preferred_lifetime_zero_ipv6(self):
- self.copy_unit_to_networkd_unit_path('25-address-section-miscellaneous.network', '12-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
-
- output = subprocess.check_output(['ip', 'address', 'show', 'dummy98']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', '-4', 'route', 'show', 'dev', 'dummy98']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'inet 10.2.3.4/16 brd 10.2.255.255 scope link deprecated dummy98')
- self.assertRegex(output, 'inet6 2001:db8:0:f101::1/64 scope global')
-
- def test_ip_route(self):
- self.copy_unit_to_networkd_unit_path('25-route-section.network', '12-dummy.netdev')
- self.start_networkd()
+ self.assertRegex(output, '149.10.124.48/28 proto kernel scope link src 149.10.124.58')
+ self.assertRegex(output, '149.10.124.64 proto static scope link')
+ self.assertRegex(output, '192.168.1.1 proto static initcwnd 20')
+ self.assertRegex(output, '192.168.1.2 proto static initrwnd 30')
- self.assertTrue(self.link_exits('dummy98'))
+ output = subprocess.check_output(['ip', '-4', 'route', 'show', 'dev', 'dummy98', 'default']).rstrip().decode('utf-8')
+ self.assertRegex(output, 'default via 149.10.125.65 proto static onlink')
+ self.assertRegex(output, 'default via 149.10.124.64 proto static')
- output = subprocess.check_output(['ip', 'route', 'list', 'dev', 'dummy98']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', 'route', 'show', 'type', 'blackhole']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, '192.168.0.1')
- self.assertRegex(output, 'static')
- self.assertRegex(output, '192.168.0.0/24')
-
- def test_ip_route_reverse(self):
- self.copy_unit_to_networkd_unit_path('25-route-reverse-order.network', '12-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
+ self.assertRegex(output, 'blackhole 202.54.1.2 proto static')
- output = subprocess.check_output(['ip', '-6', 'route', 'show', 'dev', 'dummy98']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', 'route', 'show', 'type', 'unreachable']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, '2001:1234:5:8fff:ff:ff:ff:ff')
- self.assertRegex(output, '2001:1234:5:8f63::1')
+ self.assertRegex(output, 'unreachable 202.54.1.3 proto static')
- def test_ip_route_blackhole_unreachable_prohibit(self):
- self.copy_unit_to_networkd_unit_path('25-route-type.network', '12-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
-
- output = subprocess.check_output(['ip', 'route', 'list']).rstrip().decode('utf-8')
+ output = subprocess.check_output(['ip', 'route', 'show', 'type', 'prohibit']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'blackhole')
- self.assertRegex(output, 'unreachable')
- self.assertRegex(output, 'prohibit')
+ self.assertRegex(output, 'prohibit 202.54.1.4 proto static')
subprocess.call(['ip', 'route', 'del', 'blackhole', '202.54.1.2'])
subprocess.call(['ip', 'route', 'del', 'unreachable', '202.54.1.3'])
subprocess.call(['ip', 'route', 'del', 'prohibit', '202.54.1.4'])
- def test_ip_route_tcp_window(self):
- self.copy_unit_to_networkd_unit_path('25-route-tcp-window-settings.network', '11-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('test1'))
-
- output = subprocess.check_output(['ip', 'route', 'list']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, 'initcwnd 20')
- self.assertRegex(output, 'initrwnd 30')
-
- def test_ip_route_gateway(self):
- self.copy_unit_to_networkd_unit_path('25-route-gateway.network', '12-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
-
- output = subprocess.check_output(['ip', 'route', 'list', 'dev', 'dummy98', 'default']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, 'default')
- self.assertRegex(output, 'via')
- self.assertRegex(output, '149.10.124.64')
- self.assertRegex(output, 'proto')
- self.assertRegex(output, 'static')
-
- output = subprocess.check_output(['ip', 'route', 'list', 'dev', 'dummy98', 'src', '149.10.124.58']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, '149.10.124.48/28')
- self.assertRegex(output, 'proto')
- self.assertRegex(output, 'kernel')
- self.assertRegex(output, 'scope')
- self.assertRegex(output, 'link')
-
- def test_ip_route_gateway_on_link(self):
- self.copy_unit_to_networkd_unit_path('25-route-gateway-on-link.network', '12-dummy.netdev')
- self.start_networkd()
-
- self.assertTrue(self.link_exits('dummy98'))
-
- output = subprocess.check_output(['ip', 'route', 'list', 'dev', 'dummy98', 'default']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, 'default')
- self.assertRegex(output, 'via')
- self.assertRegex(output, '149.10.125.65')
- self.assertRegex(output, 'proto')
- self.assertRegex(output, 'static')
- self.assertRegex(output, 'onlink')
-
- output = subprocess.check_output(['ip', 'route', 'list', 'dev', 'dummy98', 'src', '149.10.124.58']).rstrip().decode('utf-8')
- print(output)
- self.assertRegex(output, '149.10.124.48/28')
- self.assertRegex(output, 'proto')
- self.assertRegex(output, 'kernel')
- self.assertRegex(output, 'scope')
- self.assertRegex(output, 'link')
-
def test_ip_route_ipv6_src_route(self):
# a dummy device does not make the addresses go through tentative state, so we
# reuse a bond from an earlier test, which does make the addresses go through
def test_link_local_addressing(self):
self.copy_unit_to_networkd_unit_path('25-link-local-addressing-yes.network', '11-dummy.netdev',
'25-link-local-addressing-no.network', '12-dummy.netdev')
- self.start_networkd()
+ self.start_networkd(0)
+ self.wait_online(['test1:degraded', 'dummy98:carrier'])
self.assertTrue(self.link_exits('test1'))
self.assertTrue(self.link_exits('dummy98'))
- time.sleep(10)
-
output = subprocess.check_output(['ip', 'address', 'show', 'dev', 'test1']).rstrip().decode('utf-8')
print(output)
self.assertRegex(output, 'inet .* scope link')
test1_addr_gen_mode = '0'
if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'test1'), 'addr_gen_mode')):
- self.assertEqual(self.read_ipv6_sysctl_attr('test1', 'addr_gen_mode'), '0')
+ self.assertEqual(self.read_ipv6_sysctl_attr('test1', 'addr_gen_mode'), test1_addr_gen_mode)
if os.path.exists(os.path.join(os.path.join(network_sysctl_ipv6_path, 'dummy98'), 'addr_gen_mode')):
self.assertEqual(self.read_ipv6_sysctl_attr('dummy98', 'addr_gen_mode'), '1')
def test_sysctl(self):
self.copy_unit_to_networkd_unit_path('25-sysctl.network', '12-dummy.netdev')
- self.start_networkd()
+ self.start_networkd(0)
+ self.wait_online(['dummy98:degraded'])
self.assertTrue(self.link_exits('dummy98'))
self.assertEqual(subprocess.call(['sysctl', 'net.ipv6.conf.all.disable_ipv6=1']), 0)
self.assertEqual(subprocess.call(['sysctl', 'net.ipv6.conf.default.disable_ipv6=1']), 0)
- self.start_networkd()
+ self.start_networkd(0)
+ self.wait_online(['dummy98:routable'])
self.assertTrue(self.link_exits('dummy98'))
self.assertEqual(subprocess.call(['sysctl', 'net.ipv6.conf.all.disable_ipv6=0']), 0)
self.assertEqual(subprocess.call(['sysctl', 'net.ipv6.conf.default.disable_ipv6=0']), 0)
- self.start_networkd()
+ self.start_networkd(0)
+ self.wait_online(['dummy98:routable'])
self.assertTrue(self.link_exits('dummy98'))
class NetworkdNetWorkBondTests(unittest.TestCase, Utilities):
links = [
+ 'bond199',
'bond99',
'dummy98',
'test1']
units = [
'11-dummy.netdev',
'12-dummy.netdev',
+ '23-active-slave.network',
+ '23-bond199.network',
+ '23-primary-slave.network',
+ '23-test1-bond199.network',
+ '25-bond-active-backup-slave.netdev',
'25-bond.netdev',
'bond99.network',
'bond-slave.network']
self.link_remove(self.links)
self.remove_unit_from_networkd_path(self.units)
+ def test_bond_active_slave(self):
+ self.copy_unit_to_networkd_unit_path('23-active-slave.network', '23-bond199.network', '25-bond-active-backup-slave.netdev', '12-dummy.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('dummy98'))
+ self.assertTrue(self.link_exits('bond199'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'bond199']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'active_slave dummy98')
+
+ def test_bond_primary_slave(self):
+ self.copy_unit_to_networkd_unit_path('23-primary-slave.network', '23-test1-bond199.network', '25-bond-active-backup-slave.netdev', '11-dummy.netdev')
+ self.start_networkd()
+
+ self.assertTrue(self.link_exits('test1'))
+ self.assertTrue(self.link_exits('bond199'))
+
+ output = subprocess.check_output(['ip', '-d', 'link', 'show', 'bond199']).rstrip().decode('utf-8')
+ print(output)
+ self.assertRegex(output, 'primary test1')
+
def test_bond_operstate(self):
self.copy_unit_to_networkd_unit_path('25-bond.netdev', '11-dummy.netdev', '12-dummy.netdev',
'bond99.network','bond-slave.network')
output = subprocess.check_output(['networkctl', 'status', 'bond99']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'State: degraded \(configured\)')
+ self.assertRegex(output, 'State: degraded-carrier \(configured\)')
self.assertEqual(subprocess.call(['ip', 'link', 'set', 'dummy98', 'up']), 0)
time.sleep(2)
self.assertEqual(subprocess.call(['ip', 'link', 'set', 'dummy98', 'down']), 0)
self.assertEqual(subprocess.call(['ip', 'link', 'set', 'test1', 'down']), 0)
- time.sleep(2)
+ time.sleep(5)
output = subprocess.check_output(['networkctl', 'status', 'dummy98']).rstrip().decode('utf-8')
print(output)
output = subprocess.check_output(['networkctl', 'status', 'bond99']).rstrip().decode('utf-8')
print(output)
- self.assertRegex(output, 'State: degraded \(configured\)')
+ self.assertRegex(output, 'State: no-carrier \(configured\)')
class NetworkdNetWorkBridgeTests(unittest.TestCase, Utilities):
links = [
self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'hairpin_mode'), '1')
self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'path_cost'), '400')
self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'unicast_flood'), '1')
+ self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'multicast_flood'), '0')
self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'multicast_fast_leave'), '1')
+ if (os.path.exists('/sys/devices/virtual/net/bridge99/lower_dummy98/brport/neigh_suppress')):
+ self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'neigh_suppress'), '1')
+ self.assertEqual(self.read_bridge_port_attr('bridge99', 'dummy98', 'learning'), '0')
# CONFIG_BRIDGE_IGMP_SNOOPING=y
if (os.path.exists('/sys/devices/virtual/net/bridge00/lower_dummy98/brport/multicast_to_unicast')):
time.sleep(3)
output = subprocess.check_output(['networkctl', 'status', 'bridge99']).rstrip().decode('utf-8')
- self.assertRegex(output, 'State: degraded \(configured\)')
+ self.assertRegex(output, 'State: degraded-carrier \(configured\)')
self.assertEqual(subprocess.call(['ip', 'link', 'del', 'dummy98']), 0)
time.sleep(3)
print(output)
self.assertRegex(output, '192.168.5.*')
- # Stoping dnsmasq as networkd won't be allowed to renew the DHCP lease.
+ # Stopping dnsmasq as networkd won't be allowed to renew the DHCP lease.
self.stop_dnsmasq(dnsmasq_pid_file)
# Sleep for 120 sec as the dnsmasq minimum lease time can only be set to 120
projects / thirdparty / systemd.git / blobdiff